merged last devel

GPy/testing/bgplvm_minibatch_tests.py

@@ -1,109 +0,0 @@
-'''
-Created on 4 Sep 2015
-
-@author: maxz
-'''
-import unittest
-import numpy as np
-import GPy
-
-class BGPLVMTest(unittest.TestCase):
-
-
-    def setUp(self):
-        np.random.seed(12345)
-        X, W = np.random.normal(0,1,(100,6)), np.random.normal(0,1,(6,13))
-        Y = X.dot(W) + np.random.normal(0, .1, (X.shape[0], W.shape[1]))
-        self.inan = np.random.binomial(1, .1, Y.shape).astype(bool)
-        self.X, self.W, self.Y = X,W,Y
-        self.Q = 3
-        self.m_full = GPy.models.BayesianGPLVM(Y, self.Q)
-
-    def test_lik_comparisons_m1_s0(self):
-        # Test if the different implementations give the exact same likelihood as the full model.
-        # All of the following settings should give the same likelihood and gradients as the full model:
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=False)
-        m[:] = self.m_full[:]
-        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
-        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
-        assert(m.checkgrad())
-
-    def test_predict_missing_data(self):
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
-        m[:] = self.m_full[:]
-        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
-        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
-
-        self.assertRaises(NotImplementedError, m.predict, m.X, full_cov=True)
-
-        mu1, var1 = m.predict(m.X, full_cov=False)
-        mu2, var2 = self.m_full.predict(self.m_full.X, full_cov=False)
-        np.testing.assert_allclose(mu1, mu2)
-        np.testing.assert_allclose(var1, var2)
-
-        mu1, var1 = m.predict(m.X.mean, full_cov=True)
-        mu2, var2 = self.m_full.predict(self.m_full.X.mean, full_cov=True)
-        np.testing.assert_allclose(mu1, mu2)
-        np.testing.assert_allclose(var1[:,:,0], var2)
-
-        mu1, var1 = m.predict(m.X.mean, full_cov=False)
-        mu2, var2 = self.m_full.predict(self.m_full.X.mean, full_cov=False)
-        np.testing.assert_allclose(mu1, mu2)
-        np.testing.assert_allclose(var1[:,[0]], var2)
-
-    def test_lik_comparisons_m0_s0(self):
-        # Test if the different implementations give the exact same likelihood as the full model.
-        # All of the following settings should give the same likelihood and gradients as the full model:
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=False)
-        m[:] = self.m_full[:]
-        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
-        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
-        assert(m.checkgrad())
-
-    def test_lik_comparisons_m1_s1(self):
-        # Test if the different implementations give the exact same likelihood as the full model.
-        # All of the following settings should give the same likelihood and gradients as the full model:
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
-        m[:] = self.m_full[:]
-        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
-        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
-        assert(m.checkgrad())
-
-    def test_lik_comparisons_m0_s1(self):
-        # Test if the different implementations give the exact same likelihood as the full model.
-        # All of the following settings should give the same likelihood and gradients as the full model:
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=True, batchsize=self.Y.shape[1])
-        m[:] = self.m_full[:]
-        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
-        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
-        assert(m.checkgrad())
-
-    def test_gradients_missingdata(self):
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=False, batchsize=self.Y.shape[1])
-        assert(m.checkgrad())
-
-    def test_gradients_missingdata_stochastics(self):
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=1)
-        assert(m.checkgrad())
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=4)
-        assert(m.checkgrad())
-
-    def test_gradients_stochastics(self):
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=True, batchsize=1)
-        assert(m.checkgrad())
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=True, batchsize=4)
-        assert(m.checkgrad())
-
-    def test_predict(self):
-        # Test if the different implementations give the exact same likelihood as the full model.
-        # All of the following settings should give the same likelihood and gradients as the full model:
-        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
-        m[:] = self.m_full[:]
-        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
-        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
-        assert(m.checkgrad())
-
-
-if __name__ == "__main__":
-    #import sys;sys.argv = ['', 'Test.testName']
-    unittest.main()

GPy/testing/gp_tests.py

@@ -97,4 +97,4 @@ class Test(unittest.TestCase):
 
 if __name__ == "__main__":
     #import sys;sys.argv = ['', 'Test.testName']
-    unittest.main()
+    unittest.main()

GPy/testing/gpy_kernels_state_space_tests.py

@@ -0,0 +1,361 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015, Alex Grigorevskiy
+# Licensed under the BSD 3-clause license (see LICENSE.txt)
+"""
+Testing state space related functions.
+"""
+import unittest
+import numpy as np
+import GPy
+import GPy.models.state_space_model as SS_model
+from .state_space_main_tests import generate_x_points, generate_sine_data, \
+    generate_linear_data, generate_brownian_data, generate_linear_plus_sin
+
+#from state_space_main_tests import generate_x_points, generate_sine_data, \
+#    generate_linear_data, generate_brownian_data, generate_linear_plus_sin
+
+class StateSpaceKernelsTests(np.testing.TestCase):
+    def setUp(self):
+        pass
+
+    def run_for_model(self, X, Y, ss_kernel, kalman_filter_type = 'regular',
+                      use_cython=False, check_gradients=True,
+                      optimize=True, optimize_max_iters=250, predict_X=None,
+                      compare_with_GP=True, gp_kernel=None,
+                      mean_compare_decimal=10, var_compare_decimal=7):
+
+        m1  = SS_model.StateSpace(X,Y, ss_kernel,
+                                kalman_filter_type=kalman_filter_type,
+                                use_cython=use_cython)
+
+        m1.likelihood[:] = Y.var()/100.
+
+        if check_gradients:
+            self.assertTrue(m1.checkgrad())
+
+        if 1:#optimize:
+            m1.optimize(optimizer='lbfgsb', max_iters=1)
+
+        if compare_with_GP and (predict_X is None):
+            predict_X = X
+
+        self.assertTrue(compare_with_GP)
+        if compare_with_GP:
+            m2  = GPy.models.GPRegression(X,Y, gp_kernel)
+
+            m2[:] = m1[:]
+
+            if (predict_X is not None):
+                x_pred_reg_1 = m1.predict(predict_X)
+                x_quant_reg_1 = m1.predict_quantiles(predict_X)
+
+            x_pred_reg_2 = m2.predict(predict_X)
+            x_quant_reg_2 = m2.predict_quantiles(predict_X)
+
+            np.testing.assert_array_almost_equal(x_pred_reg_1[0], x_pred_reg_2[0], mean_compare_decimal)
+            np.testing.assert_array_almost_equal(x_pred_reg_1[1], x_pred_reg_2[1], var_compare_decimal)
+            np.testing.assert_array_almost_equal(x_quant_reg_1[0], x_quant_reg_2[0], mean_compare_decimal)
+            np.testing.assert_array_almost_equal(x_quant_reg_1[1], x_quant_reg_2[1], mean_compare_decimal)
+            np.testing.assert_array_almost_equal(m1.gradient, m2.gradient, var_compare_decimal)
+            np.testing.assert_almost_equal(m1.log_likelihood(), m2.log_likelihood(), var_compare_decimal)
+
+
+    def test_Matern32_kernel(self,):
+        np.random.seed(234) # seed the random number generator
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=50, x_interval = (0, 20), random=True)
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_Matern32(1,active_dims=[0,])
+        gp_kernel = GPy.kern.Matern32(1,active_dims=[0,])
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                           predict_X=X,
+                           compare_with_GP=True,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=5, var_compare_decimal=5)
+
+    def test_Matern52_kernel(self,):
+        np.random.seed(234) # seed the random number generator
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=50, x_interval = (0, 20), random=True)
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_Matern52(1,active_dims=[0,])
+        gp_kernel = GPy.kern.Matern52(1,active_dims=[0,])
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                           optimize = True, predict_X=X,
+                           compare_with_GP=True, gp_kernel=gp_kernel,
+                           mean_compare_decimal=5, var_compare_decimal=5)
+
+    def test_RBF_kernel(self,):
+        np.random.seed(234) # seed the random number generator
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=50, x_interval = (0, 20), random=True)
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_RBF(1, 110., 1.5, active_dims=[0,])
+        gp_kernel = GPy.kern.RBF(1, 110., 1.5, active_dims=[0,])
+        
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                           predict_X=X,
+                           gp_kernel=gp_kernel,
+                           optimize_max_iters=1000,
+                           mean_compare_decimal=2, var_compare_decimal=1)
+
+    def test_periodic_kernel(self,):
+        np.random.seed(322) # seed the random number generator
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=50, x_interval = (0, 20), random=True)
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+        ss_kernel.lengthscale.constrain_bounded(0.27, 1000)
+        ss_kernel.period.constrain_bounded(0.17, 100)
+
+        gp_kernel = GPy.kern.StdPeriodic(1,active_dims=[0,])
+        gp_kernel.lengthscale.constrain_bounded(0.27, 1000)
+        gp_kernel.period.constrain_bounded(0.17, 100)
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                           predict_X=X,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=3, var_compare_decimal=3)
+
+    def test_quasi_periodic_kernel(self,):
+        np.random.seed(329) # seed the random number generator
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=50, x_interval = (0, 20), random=True)
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_Matern32(1)*GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+        ss_kernel.std_periodic.lengthscale.constrain_bounded(0.25, 1000)
+        ss_kernel.std_periodic.period.constrain_bounded(0.15, 100)
+
+        gp_kernel = GPy.kern.Matern32(1)*GPy.kern.StdPeriodic(1,active_dims=[0,])
+        gp_kernel.std_periodic.lengthscale.constrain_bounded(0.25, 1000)
+        gp_kernel.std_periodic.period.constrain_bounded(0.15, 100)
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                            predict_X=X,
+                            gp_kernel=gp_kernel,
+                            mean_compare_decimal=1, var_compare_decimal=2)
+
+    def test_linear_kernel(self,):
+
+        np.random.seed(234) # seed the random number generator
+        (X,Y) = generate_linear_data(x_points=None, tangent=2.0, add_term=20.0, noise_var=2.0,
+                    plot = False, points_num=50, x_interval = (0, 20), random=True)
+
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_Linear(1,X,active_dims=[0,]) + GPy.kern.sde_Bias(1, active_dims=[0,])
+        gp_kernel = GPy.kern.Linear(1, active_dims=[0,]) + GPy.kern.Bias(1, active_dims=[0,])
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients= False,
+                           predict_X=X,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=5, var_compare_decimal=5)
+
+    def test_brownian_kernel(self,):
+        np.random.seed(234) # seed the random number generator
+        (X,Y) = generate_brownian_data(x_points=None, kernel_var=2.0, noise_var = 0.1,
+                    plot = False, points_num=50, x_interval = (0, 20), random=True)
+
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_Brownian()
+        gp_kernel = GPy.kern.Brownian()
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                            predict_X=X,
+                            gp_kernel=gp_kernel,
+                            mean_compare_decimal=4, var_compare_decimal=4)
+
+    def test_exponential_kernel(self,):
+        np.random.seed(12345) # seed the random number generator
+        (X,Y) = generate_linear_data(x_points=None, tangent=1.0, add_term=20.0, noise_var=2.0,
+                    plot = False, points_num=10, x_interval = (0, 20), random=True)
+
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        ss_kernel = GPy.kern.sde_Exponential(1, Y.var(), X.ptp()/2., active_dims=[0,])
+        gp_kernel = GPy.kern.Exponential(1, Y.var(), X.ptp()/2., active_dims=[0,])
+
+        Y -= Y.mean()
+
+        self.run_for_model(X, Y, ss_kernel, check_gradients=True,
+                      predict_X=X,
+                      gp_kernel=gp_kernel,
+                      optimize_max_iters=1000,
+                      mean_compare_decimal=2, var_compare_decimal=2)
+
+    def test_kernel_addition(self,):
+        #np.random.seed(329) # seed the random number generator
+        np.random.seed(333)
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=5.0, noise_var=2.0,
+                        plot = False, points_num=100, x_interval = (0, 40), random=True)
+
+        (X1,Y1) = generate_linear_data(x_points=X, tangent=1.0, add_term=20.0, noise_var=0.0,
+                    plot = False, points_num=100, x_interval = (0, 40), random=True)
+
+        # Sine data <-
+        Y = Y + Y1
+        Y -= Y.mean()
+
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        def get_new_kernels():
+            ss_kernel = GPy.kern.sde_Linear(1,X,variances=1) + GPy.kern.sde_StdPeriodic(1,period=5.0, variance=300, lengthscale=3., active_dims=[0,])
+            #ss_kernel.std_periodic.lengthscale.constrain_bounded(0.25, 1000)
+            #ss_kernel.std_periodic.period.constrain_bounded(3, 8)
+
+            gp_kernel = GPy.kern.Linear(1,variances=1) + GPy.kern.StdPeriodic(1,period=5.0, variance=300, lengthscale=3., active_dims=[0,])
+            #gp_kernel.std_periodic.lengthscale.constrain_bounded(0.25, 1000)
+            #gp_kernel.std_periodic.period.constrain_bounded(3, 8)
+
+            return ss_kernel, gp_kernel
+
+        # Cython is available only with svd.
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X, Y, ss_kernel, kalman_filter_type = 'svd',
+                           use_cython=True, optimize_max_iters=10, check_gradients=False,
+                           predict_X=X,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=5, var_compare_decimal=5)
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X, Y, ss_kernel, kalman_filter_type = 'regular',
+                           use_cython=False, optimize_max_iters=10, check_gradients=True,
+                           predict_X=X,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=5, var_compare_decimal=5)
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X, Y, ss_kernel, kalman_filter_type = 'svd',
+                           use_cython=False, optimize_max_iters=10, check_gradients=False,
+                           predict_X=X,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=5, var_compare_decimal=5)
+
+
+    def test_kernel_multiplication(self,):
+        np.random.seed(329) # seed the random number generator
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=50, x_interval = (0, 20), random=True)
+
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+
+        def get_new_kernels():
+            ss_kernel = GPy.kern.sde_Matern32(1)*GPy.kern.sde_Matern52(1)
+            gp_kernel = GPy.kern.Matern32(1)*GPy.kern.sde_Matern52(1)
+
+            return ss_kernel, gp_kernel
+
+        ss_kernel, gp_kernel = get_new_kernels()
+
+        #import ipdb;ipdb.set_trace()
+        self.run_for_model(X, Y, ss_kernel, kalman_filter_type = 'svd',
+                           use_cython=True, optimize_max_iters=10, check_gradients=True,
+                            predict_X=X,
+                            gp_kernel=gp_kernel,
+                            mean_compare_decimal=2, var_compare_decimal=2)
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X, Y, ss_kernel, kalman_filter_type = 'regular',
+                           use_cython=False, optimize_max_iters=10, check_gradients=True,
+                            predict_X=X,
+                            gp_kernel=gp_kernel,
+                            mean_compare_decimal=2, var_compare_decimal=2)
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X, Y, ss_kernel, kalman_filter_type = 'svd',
+                           use_cython=False, optimize_max_iters=10, check_gradients=True,
+                            predict_X=X,
+                            gp_kernel=gp_kernel,
+                            mean_compare_decimal=2, var_compare_decimal=2)
+
+    def test_forecast(self,):
+        """
+        Test time-series forecasting.
+        """
+
+        # Generate data ->
+        np.random.seed(339) # seed the random number generator
+        #import pdb; pdb.set_trace()
+        (X,Y) = generate_sine_data(x_points=None, sin_period=5.0, sin_ampl=5.0, noise_var=2.0,
+                        plot = False, points_num=100, x_interval = (0, 40), random=True)
+
+        (X1,Y1) = generate_linear_data(x_points=X, tangent=1.0, add_term=20.0, noise_var=0.0,
+                    plot = False, points_num=100, x_interval = (0, 40), random=True)
+
+        Y = Y + Y1
+
+        X_train = X[X <= 20]
+        Y_train = Y[X <= 20]
+        X_test = X[X > 20]
+        Y_test = Y[X > 20]
+
+        X.shape = (X.shape[0],1); Y.shape = (Y.shape[0],1)
+        X_train.shape = (X_train.shape[0],1); Y_train.shape = (Y_train.shape[0],1)
+        X_test.shape = (X_test.shape[0],1); Y_test.shape = (Y_test.shape[0],1)
+        # Generate data <-
+
+        #import pdb; pdb.set_trace()
+
+        def get_new_kernels():
+            periodic_kernel = GPy.kern.StdPeriodic(1,active_dims=[0,])
+            gp_kernel = GPy.kern.Linear(1, active_dims=[0,]) + GPy.kern.Bias(1, active_dims=[0,]) + periodic_kernel
+            gp_kernel.std_periodic.lengthscale.constrain_bounded(0.25, 1000)
+            gp_kernel.std_periodic.period.constrain_bounded(0.15, 100)
+
+            periodic_kernel = GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+            ss_kernel = GPy.kern.sde_Linear(1,X,active_dims=[0,]) + \
+                GPy.kern.sde_Bias(1, active_dims=[0,]) + periodic_kernel
+
+            ss_kernel.std_periodic.lengthscale.constrain_bounded(0.25, 1000)
+            ss_kernel.std_periodic.period.constrain_bounded(0.15, 100)
+
+            return ss_kernel, gp_kernel
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X_train, Y_train, ss_kernel, kalman_filter_type = 'regular',
+                           use_cython=False, optimize_max_iters=30, check_gradients=True,
+                           predict_X=X_test,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=2, var_compare_decimal=2)
+
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X_train, Y_train, ss_kernel, kalman_filter_type = 'svd',
+                           use_cython=False, optimize_max_iters=30, check_gradients=False,
+                           predict_X=X_test,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=2, var_compare_decimal=2)
+
+        ss_kernel, gp_kernel = get_new_kernels()
+        self.run_for_model(X_train, Y_train, ss_kernel, kalman_filter_type = 'svd',
+                           use_cython=True, optimize_max_iters=30, check_gradients=False,
+                           predict_X=X_test,
+                           gp_kernel=gp_kernel,
+                           mean_compare_decimal=2, var_compare_decimal=2)
+
+if __name__ == "__main__":
+    print("Running state-space inference tests...")
+    unittest.main()
+
+    #tt = StateSpaceKernelsTests('test_periodic_kernel')
+    #import pdb; pdb.set_trace()
+    #tt.test_Matern32_kernel()
+    #tt.test_Matern52_kernel()
+    #tt.test_RBF_kernel()
+    #tt.test_periodic_kernel()
+    #tt.test_quasi_periodic_kernel()
+    #tt.test_linear_kernel()
+    #tt.test_brownian_kernel()
+    #tt.test_exponential_kernel()
+    #tt.test_kernel_addition()
+    #tt.test_kernel_multiplication()
+    #tt.test_forecast()
+

GPy/testing/inference_tests.py

@@ -50,7 +50,6 @@ class InferenceXTestCase(unittest.TestCase):
         x, mi = m.infer_newX(m.Y, optimize=True)
         np.testing.assert_array_almost_equal(m.X, mi.X, decimal=2)
 
-
 class HMCSamplerTest(unittest.TestCase):
 
     def test_sampling(self):
@@ -65,6 +64,21 @@ class HMCSamplerTest(unittest.TestCase):
 
         hmc = GPy.inference.mcmc.HMC(m,stepsize=1e-2)
         s = hmc.sample(num_samples=3)
+        
+class MCMCSamplerTest(unittest.TestCase):
+
+    def test_sampling(self):
+        np.random.seed(1)
+        x = np.linspace(0.,2*np.pi,100)[:,None]
+        y = -np.cos(x)+np.random.randn(*x.shape)*0.3+1
+
+        m = GPy.models.GPRegression(x,y)
+        m.kern.lengthscale.set_prior(GPy.priors.Gamma.from_EV(1.,10.))
+        m.kern.variance.set_prior(GPy.priors.Gamma.from_EV(1.,10.))
+        m.likelihood.variance.set_prior(GPy.priors.Gamma.from_EV(1.,10.))
+
+        mcmc = GPy.inference.mcmc.Metropolis_Hastings(m)
+        mcmc.sample(Ntotal=100, Nburn=10)
 
 if __name__ == "__main__":
     unittest.main()

GPy/testing/kernel_tests.py

@@ -6,6 +6,7 @@ import numpy as np
 import GPy
 from GPy.core.parameterization.param import Param
 from ..util.config import config
+from unittest.case import skip
 
 verbose = 0
 
@@ -329,8 +330,13 @@ class KernelGradientTestsContinuous(unittest.TestCase):
         k.randomize()
         self.assertTrue(check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose))
 
+    def test_WhiteHeteroscedastic(self):
+        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))
+
     def test_standard_periodic(self):
-        k = GPy.kern.StdPeriodic(self.D, self.D-1)
+        k = GPy.kern.StdPeriodic(self.D)
         k.randomize()
         self.assertTrue(check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose))
 
@@ -339,11 +345,14 @@ class KernelTestsMiscellaneous(unittest.TestCase):
         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))
+        self.rbf.randomize()
         self.linear = GPy.kern.Linear(2, active_dims=(3,9))
+        self.linear.randomize()
         self.matern = GPy.kern.Matern32(3, active_dims=np.array([1,7,9]))
+        self.matern.randomize()
         self.sumkern = self.rbf + self.linear
         self.sumkern += self.matern
-        self.sumkern.randomize()
+        #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)))
@@ -353,6 +362,21 @@ class KernelTestsMiscellaneous(unittest.TestCase):
     def test_active_dims(self):
         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
+        np.testing.assert_array_equal(tmp.active_dims, [0,2,3,9])
+        np.testing.assert_array_equal(tmp._all_dims_active, range(10))
+        tmp = self.matern+self.rbf
+        np.testing.assert_array_equal(tmp.active_dims, [0,1,2,7,9])
+        np.testing.assert_array_equal(tmp._all_dims_active, range(10))
+        tmp = self.matern+self.rbf*self.linear
+        np.testing.assert_array_equal(tmp.active_dims, [0,1,2,3,7,9])
+        np.testing.assert_array_equal(tmp._all_dims_active, range(10))
+        tmp = self.matern+self.rbf+self.linear
+        np.testing.assert_array_equal(tmp.active_dims, [0,1,2,3,7,9])
+        np.testing.assert_array_equal(tmp._all_dims_active, range(10))
+        tmp = self.matern*self.rbf*self.linear
+        np.testing.assert_array_equal(tmp.active_dims, [0,1,2,3,7,9])
+        np.testing.assert_array_equal(tmp._all_dims_active, range(10))
 
 class KernelTestsNonContinuous(unittest.TestCase):
     def setUp(self):
@@ -371,8 +395,13 @@ class KernelTestsNonContinuous(unittest.TestCase):
         self.X2[:(N0*2), -1] = 0
         self.X2[(N0*2):, -1] = 1
 
-    @unittest.expectedFailure
     def test_IndependentOutputs(self):
+        k = [GPy.kern.RBF(1, active_dims=[1], name='rbf1'), GPy.kern.RBF(self.D, active_dims=range(self.D), name='rbf012'), GPy.kern.RBF(2, active_dims=[0,2], name='rbf02')]
+        kern = GPy.kern.IndependentOutputs(k, -1, name='ind_split')
+        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):
         k = GPy.kern.RBF(self.D, active_dims=range(self.D))
         kern = GPy.kern.IndependentOutputs(k, -1, 'ind_single')
         self.assertTrue(check_kernel_gradient_functions(kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1))
@@ -380,8 +409,13 @@ class KernelTestsNonContinuous(unittest.TestCase):
         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))
 
-    @unittest.expectedFailure
     def test_Hierarchical(self):
+        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')
+        np.testing.assert_array_equal(kern.active_dims, [-1,0,2])
+        np.testing.assert_array_equal(kern._all_dims_active, [0,1,2,-1])
+
+    def test_Hierarchical_gradients(self):
         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))
@@ -393,6 +427,10 @@ class KernelTestsNonContinuous(unittest.TestCase):
         X2 = self.X2[self.X2[:,-1]!=2]
         self.assertTrue(check_kernel_gradient_functions(kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1))
 
+    def test_Coregionalize(self):
+        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))
+
 @unittest.skipIf(not config.getboolean('cython', 'working'),"Cython modules have not been built on this machine")
 class Coregionalize_cython_test(unittest.TestCase):
     """

GPy/testing/minibatch_tests.py

@@ -0,0 +1,226 @@
+'''
+Created on 4 Sep 2015
+
+@author: maxz
+'''
+import unittest
+import numpy as np
+import GPy
+
+class BGPLVMTest(unittest.TestCase):
+
+
+    def setUp(self):
+        np.random.seed(12345)
+        X, W = np.random.normal(0,1,(100,6)), np.random.normal(0,1,(6,13))
+        Y = X.dot(W) + np.random.normal(0, .1, (X.shape[0], W.shape[1]))
+        self.inan = np.random.binomial(1, .1, Y.shape).astype(bool)
+        self.X, self.W, self.Y = X,W,Y
+        self.Q = 3
+        self.m_full = GPy.models.BayesianGPLVM(Y, self.Q)
+
+    def test_lik_comparisons_m1_s0(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=False)
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_predict_missing_data(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+
+        self.assertRaises(NotImplementedError, m.predict, m.X, full_cov=True)
+
+        mu1, var1 = m.predict(m.X, full_cov=False)
+        mu2, var2 = self.m_full.predict(self.m_full.X, full_cov=False)
+        np.testing.assert_allclose(mu1, mu2)
+        np.testing.assert_allclose(var1, var2)
+
+        mu1, var1 = m.predict(m.X.mean, full_cov=True)
+        mu2, var2 = self.m_full.predict(self.m_full.X.mean, full_cov=True)
+        np.testing.assert_allclose(mu1, mu2)
+        np.testing.assert_allclose(var1[:,:,0], var2)
+
+        mu1, var1 = m.predict(m.X.mean, full_cov=False)
+        mu2, var2 = self.m_full.predict(self.m_full.X.mean, full_cov=False)
+        np.testing.assert_allclose(mu1, mu2)
+        np.testing.assert_allclose(var1[:,[0]], var2)
+
+    def test_lik_comparisons_m0_s0(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=self.m_full.X.variance.values, missing_data=False, stochastic=False)
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_lik_comparisons_m1_s1(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_lik_comparisons_m0_s1(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_gradients_missingdata(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=False, batchsize=self.Y.shape[1])
+        assert(m.checkgrad())
+
+    def test_gradients_missingdata_stochastics(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=1)
+        assert(m.checkgrad())
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=4)
+        assert(m.checkgrad())
+
+    def test_gradients_stochastics(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=True, batchsize=1)
+        assert(m.checkgrad())
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=False, stochastic=True, batchsize=4)
+        assert(m.checkgrad())
+
+    def test_predict(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+class SparseGPMinibatchTest(unittest.TestCase):
+
+
+    def setUp(self):
+        np.random.seed(12345)
+        X, W = np.random.normal(0,1,(100,6)), np.random.normal(0,1,(6,13))
+        Y = X.dot(W) + np.random.normal(0, .1, (X.shape[0], W.shape[1]))
+        self.inan = np.random.binomial(1, .1, Y.shape).astype(bool)
+        self.X, self.W, self.Y = X,W,Y
+        self.Q = 3
+        self.m_full = GPy.models.SparseGPLVM(Y, self.Q, kernel=GPy.kern.RBF(self.Q, ARD=True))
+
+    def test_lik_comparisons_m1_s0(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=False)
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_sparsegp_init(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        np.random.seed(1234)
+        Z = self.X[np.random.choice(self.X.shape[0], replace=False, size=10)].copy()
+        Q = Z.shape[1]
+        m = GPy.models.sparse_gp_minibatch.SparseGPMiniBatch(self.X, self.Y, Z, GPy.kern.RBF(Q)+GPy.kern.Matern32(Q)+GPy.kern.Bias(Q), GPy.likelihoods.Gaussian(), missing_data=True, stochastic=False)
+        assert(m.checkgrad())
+        m.optimize('adadelta', max_iters=10)
+        assert(m.checkgrad())
+
+        m = GPy.models.sparse_gp_minibatch.SparseGPMiniBatch(self.X, self.Y, Z, GPy.kern.RBF(Q)+GPy.kern.Matern32(Q)+GPy.kern.Bias(Q), GPy.likelihoods.Gaussian(), missing_data=True, stochastic=True)
+        assert(m.checkgrad())
+        m.optimize('rprop', max_iters=10)
+        assert(m.checkgrad())
+        
+        m = GPy.models.sparse_gp_minibatch.SparseGPMiniBatch(self.X, self.Y, Z, GPy.kern.RBF(Q)+GPy.kern.Matern32(Q)+GPy.kern.Bias(Q), GPy.likelihoods.Gaussian(), missing_data=False, stochastic=False)
+        assert(m.checkgrad())
+        m.optimize('rprop', max_iters=10)
+        assert(m.checkgrad())
+        
+        m = GPy.models.sparse_gp_minibatch.SparseGPMiniBatch(self.X, self.Y, Z, GPy.kern.RBF(Q)+GPy.kern.Matern32(Q)+GPy.kern.Bias(Q), GPy.likelihoods.Gaussian(), missing_data=False, stochastic=True)
+        assert(m.checkgrad())
+        m.optimize('adadelta', max_iters=10)
+        assert(m.checkgrad())
+
+    def test_predict_missing_data(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+
+        mu1, var1 = m.predict(m.X, full_cov=False)
+        mu2, var2 = self.m_full.predict(self.m_full.X, full_cov=False)
+        np.testing.assert_allclose(mu1, mu2)
+        for i in range(var1.shape[1]):
+            np.testing.assert_allclose(var1[:,[i]], var2)
+
+        mu1, var1 = m.predict(m.X, full_cov=True)
+        mu2, var2 = self.m_full.predict(self.m_full.X, full_cov=True)
+        np.testing.assert_allclose(mu1, mu2)
+        for i in range(var1.shape[2]):
+            np.testing.assert_allclose(var1[:,:,i], var2)
+            
+    def test_lik_comparisons_m0_s0(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=False, stochastic=False)
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_lik_comparisons_m1_s1(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_lik_comparisons_m0_s1(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=False, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+    def test_gradients_missingdata(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=False, batchsize=self.Y.shape[1])
+        assert(m.checkgrad())
+
+    def test_gradients_missingdata_stochastics(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=True, batchsize=1)
+        assert(m.checkgrad())
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=True, batchsize=4)
+        assert(m.checkgrad())
+
+    def test_gradients_stochastics(self):
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=False, stochastic=True, batchsize=1)
+        assert(m.checkgrad())
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=False, stochastic=True, batchsize=4)
+        assert(m.checkgrad())
+
+    def test_predict(self):
+        # Test if the different implementations give the exact same likelihood as the full model.
+        # All of the following settings should give the same likelihood and gradients as the full model:
+        m = GPy.models.bayesian_gplvm_minibatch.BayesianGPLVMMiniBatch(self.Y, self.Q, X_variance=False, missing_data=True, stochastic=True, batchsize=self.Y.shape[1])
+        m[:] = self.m_full[:]
+        np.testing.assert_almost_equal(m.log_likelihood(), self.m_full.log_likelihood(), 7)
+        np.testing.assert_allclose(m.gradient, self.m_full.gradient)
+        assert(m.checkgrad())
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

GPy/testing/model_tests.py

@@ -22,6 +22,44 @@ class MiscTests(unittest.TestCase):
         self.assertTrue(m.checkgrad())
         m.predict(m.X)
 
+    def test_raw_predict_numerical_stability(self):
+        """
+        Test whether the predicted variance of normal GP goes negative under numerical unstable situation.
+        Thanks simbartonels@github for reporting the bug and providing the following example.
+        """
+
+        # set seed for reproducability
+        np.random.seed(3)
+        # Definition of the Branin test function
+        def branin(X):
+            y = (X[:,1]-5.1/(4*np.pi**2)*X[:,0]**2+5*X[:,0]/np.pi-6)**2
+            y += 10*(1-1/(8*np.pi))*np.cos(X[:,0])+10
+            return(y)
+        # Training set defined as a 5*5 grid:
+        xg1 = np.linspace(-5,10,5)
+        xg2 = np.linspace(0,15,5)
+        X = np.zeros((xg1.size * xg2.size,2))
+        for i,x1 in enumerate(xg1):
+            for j,x2 in enumerate(xg2):
+                X[i+xg1.size*j,:] = [x1,x2]
+        Y = branin(X)[:,None]
+        # Fit a GP
+        # Create an exponentiated quadratic plus bias covariance function
+        k = GPy.kern.RBF(input_dim=2, ARD = True)
+        # Build a GP model
+        m = GPy.models.GPRegression(X,Y,k)
+        # fix the noise variance
+        m.likelihood.variance.fix(1e-5)
+        # Randomize the model and optimize
+        m.randomize()
+        m.optimize()
+        # Compute the mean of model prediction on 1e5 Monte Carlo samples
+        Xp = np.random.uniform(size=(1e5,2))
+        Xp[:,0] = Xp[:,0]*15-5
+        Xp[:,1] = Xp[:,1]*15
+        _, var = m.predict(Xp)
+        self.assertTrue(np.all(var>=0.))
+
     def test_raw_predict(self):
         k = GPy.kern.RBF(1)
         m = GPy.models.GPRegression(self.X, self.Y, kernel=k)
@@ -31,13 +69,13 @@ class MiscTests(unittest.TestCase):
         K_hat = k.K(self.X_new) - k.K(self.X_new, self.X).dot(Kinv).dot(k.K(self.X, self.X_new))
         mu_hat = k.K(self.X_new, self.X).dot(Kinv).dot(m.Y_normalized)
 
-        mu, covar = m._raw_predict(self.X_new, full_cov=True)
+        mu, covar = m.predict_noiseless(self.X_new, full_cov=True)
         self.assertEquals(mu.shape, (self.N_new, self.D))
         self.assertEquals(covar.shape, (self.N_new, self.N_new))
         np.testing.assert_almost_equal(K_hat, covar)
         np.testing.assert_almost_equal(mu_hat, mu)
 
-        mu, var = m._raw_predict(self.X_new)
+        mu, var = m.predict_noiseless(self.X_new)
         self.assertEquals(mu.shape, (self.N_new, self.D))
         self.assertEquals(var.shape, (self.N_new, 1))
         np.testing.assert_almost_equal(np.diag(K_hat)[:, None], var)
@@ -110,6 +148,28 @@ class MiscTests(unittest.TestCase):
         assert(gc.checkgrad())
         assert(gc2.checkgrad())
 
+    def test_predict_uncertain_inputs(self):
+        """ Projection of Gaussian through a linear function is still gaussian, and moments are analytical to compute, so we can check this case for predictions easily """
+        X = np.linspace(-5,5, 10)[:, None]
+        Y = 2*X + np.random.randn(*X.shape)*1e-3
+        m = GPy.models.BayesianGPLVM(Y, 1, X=X, kernel=GPy.kern.Linear(1), num_inducing=1)
+        m.Gaussian_noise[:] = 1e-4
+        m.X.mean[:] = X[:]
+        m.X.variance[:] = 1e-5
+        m.X.fix()
+        m.optimize()
+        X_pred_mu = np.random.randn(5, 1)
+        X_pred_var = np.random.rand(5, 1) + 1e-5
+        from GPy.core.parameterization.variational import NormalPosterior
+        X_pred = NormalPosterior(X_pred_mu, X_pred_var)
+        # mu = \int f(x)q(x|mu,S) dx = \int 2x.q(x|mu,S) dx = 2.mu
+        # S = \int (f(x) - m)^2q(x|mu,S) dx = \int f(x)^2 q(x) dx - mu**2 = 4(mu^2 + S) - (2.mu)^2 = 4S
+        Y_mu_true = 2*X_pred_mu
+        Y_var_true = 4*X_pred_var
+        Y_mu_pred, Y_var_pred = m.predict_noiseless(X_pred)
+        np.testing.assert_allclose(Y_mu_true, Y_mu_pred, rtol=1e-4)
+        np.testing.assert_allclose(Y_var_true, Y_var_pred, rtol=1e-4)
+
     def test_sparse_raw_predict(self):
         k = GPy.kern.RBF(1)
         m = GPy.models.SparseGPRegression(self.X, self.Y, kernel=k)
@@ -119,14 +179,15 @@ class MiscTests(unittest.TestCase):
         # Not easy to check if woodbury_inv is correct in itself as it requires a large derivation and expression
         Kinv = m.posterior.woodbury_inv
         K_hat = k.K(self.X_new) - k.K(self.X_new, Z).dot(Kinv).dot(k.K(Z, self.X_new))
+        K_hat = np.clip(K_hat, 1e-15, np.inf)
 
-        mu, covar = m._raw_predict(self.X_new, full_cov=True)
+        mu, covar = m.predict_noiseless(self.X_new, full_cov=True)
         self.assertEquals(mu.shape, (self.N_new, self.D))
         self.assertEquals(covar.shape, (self.N_new, self.N_new))
         np.testing.assert_almost_equal(K_hat, covar)
         # np.testing.assert_almost_equal(mu_hat, mu)
 
-        mu, var = m._raw_predict(self.X_new)
+        mu, var = m.predict_noiseless(self.X_new)
         self.assertEquals(mu.shape, (self.N_new, self.D))
         self.assertEquals(var.shape, (self.N_new, 1))
         np.testing.assert_almost_equal(np.diag(K_hat)[:, None], var)
@@ -368,7 +429,6 @@ class MiscTests(unittest.TestCase):
         warp_m.predict(X)
 
 
-
 class GradientTests(np.testing.TestCase):
     def setUp(self):
         ######################################
@@ -537,16 +597,27 @@ class GradientTests(np.testing.TestCase):
         rbflin = GPy.kern.RBF(1) + GPy.kern.White(1)
         self.check_model(rbflin, model_type='SparseGPRegression', dimension=1, uncertain_inputs=1)
 
+
     def test_GPLVM_rbf_bias_white_kern_2D(self):
         """ Testing GPLVM with rbf + bias kernel """
         N, input_dim, D = 50, 1, 2
         X = np.random.rand(N, input_dim)
-        k = GPy.kern.RBF(input_dim, 0.5, 0.9 * np.ones((1,))) + GPy.kern.Bias(input_dim, 0.1) + GPy.kern.White(input_dim, 0.05)
+        k = GPy.kern.RBF(input_dim, 0.5, 0.9 * np.ones((1,))) + GPy.kern.Bias(input_dim, 0.1) + GPy.kern.White(input_dim, 0.05) + GPy.kern.Matern32(input_dim) + GPy.kern.Matern52(input_dim)
         K = k.K(X)
         Y = np.random.multivariate_normal(np.zeros(N), K, input_dim).T
         m = GPy.models.GPLVM(Y, input_dim, kernel=k)
         self.assertTrue(m.checkgrad())
 
+    def test_SparseGPLVM_rbf_bias_white_kern_2D(self):
+        """ Testing GPLVM with rbf + bias kernel """
+        N, input_dim, D = 50, 1, 2
+        X = np.random.rand(N, input_dim)
+        k = GPy.kern.RBF(input_dim, 0.5, 0.9 * np.ones((1,))) + GPy.kern.Bias(input_dim, 0.1) + GPy.kern.White(input_dim, 0.05) + GPy.kern.Matern32(input_dim) + GPy.kern.Matern52(input_dim)
+        K = k.K(X)
+        Y = np.random.multivariate_normal(np.zeros(N), K, input_dim).T
+        m = GPy.models.SparseGPLVM(Y, input_dim, kernel=k)
+        self.assertTrue(m.checkgrad())
+
     def test_BCGPLVM_rbf_bias_white_kern_2D(self):
         """ Testing GPLVM with rbf + bias kernel """
         N, input_dim, D = 50, 1, 2
@@ -680,6 +751,7 @@ class GradientTests(np.testing.TestCase):
         self.assertTrue( np.allclose(var1, var2) )
 
     def test_gp_VGPC(self):
+        np.random.seed(10)
         num_obs = 25
         X = np.random.randint(0, 140, num_obs)
         X = X[:, None]
@@ -687,8 +759,23 @@ class GradientTests(np.testing.TestCase):
         kern = GPy.kern.Bias(1) + GPy.kern.RBF(1)
         lik = GPy.likelihoods.Gaussian()
         m = GPy.models.GPVariationalGaussianApproximation(X, Y, kernel=kern, likelihood=lik)
+        m.randomize()
         self.assertTrue(m.checkgrad())
 
+    def test_ssgplvm(self):
+        from GPy import kern
+        from GPy.models import SSGPLVM
+        from GPy.examples.dimensionality_reduction import _simulate_matern
+
+        np.random.seed(10)
+        D1, D2, D3, N, num_inducing, Q = 13, 5, 8, 45, 3, 9
+        _, _, Ylist = _simulate_matern(D1, D2, D3, N, num_inducing, False)
+        Y = Ylist[0]
+        k = kern.Linear(Q, ARD=True)  # + kern.white(Q, _np.exp(-2)) # + kern.bias(Q)
+        # k = kern.RBF(Q, ARD=True, lengthscale=10.)
+        m = SSGPLVM(Y, Q, init="rand", num_inducing=num_inducing, kernel=k, group_spike=True)
+        m.randomize()
+        self.assertTrue(m.checkgrad())
 
 if __name__ == "__main__":
     print("Running unit tests, please be (very) patient...")

GPy/testing/plotting_tests.py

@@ -33,12 +33,18 @@
 # SKIPPING PLOTTING BECAUSE IT BEHAVES DIFFERENTLY ON DIFFERENT
 # SYSTEMS, AND WILL MISBEHAVE
 from nose import SkipTest
-raise SkipTest("Skipping Matplotlib testing")
+#raise SkipTest("Skipping Matplotlib testing")
 #===============================================================================
 
-import matplotlib
+try:
+    import matplotlib
+    matplotlib.use('agg')
+except ImportError:
+    # matplotlib not installed
+    from nose import SkipTest
+    raise SkipTest("Skipping Matplotlib testing")
+
 from unittest.case import TestCase
-matplotlib.use('agg')
 
 import numpy as np
 import GPy, os
@@ -83,6 +89,9 @@ def _image_directories():
         cbook.mkdirs(result_dir)
     return baseline_dir, result_dir
 
+baseline_dir, result_dir = _image_directories()
+if not os.path.exists(baseline_dir):
+    raise SkipTest("Not installed from source, baseline not available. Install from source to test plotting")
 
 def _sequenceEqual(a, b):
     assert len(a) == len(b), "Sequences not same length"
@@ -93,14 +102,18 @@ def _notFound(path):
     raise IOError('File {} not in baseline')
 
 def _image_comparison(baseline_images, extensions=['pdf','svg','png'], tol=11):
-    baseline_dir, result_dir = _image_directories()
     for num, base in zip(plt.get_fignums(), baseline_images):
         for ext in extensions:
             fig = plt.figure(num)
-            fig.axes[0].set_axis_off()
-            fig.set_frameon(False)
+            #fig.axes[0].set_axis_off()
+            #fig.set_frameon(False)
             fig.canvas.draw()
-            fig.savefig(os.path.join(result_dir, "{}.{}".format(base, ext)), transparent=True, edgecolor='none', facecolor='none')
+            fig.savefig(os.path.join(result_dir, "{}.{}".format(base, ext)),
+                        transparent=True,
+                        edgecolor='none',
+                        facecolor='none',
+                        #bbox='tight'
+                        )
     for num, base in zip(plt.get_fignums(), baseline_images):
         for ext in extensions:
             #plt.close(num)
@@ -109,16 +122,16 @@ def _image_comparison(baseline_images, extensions=['pdf','svg','png'], tol=11):
             def do_test():
                 err = compare_images(expected, actual, tol, in_decorator=True)
                 if err:
-                    raise ImageComparisonFailure("Error between {} and {} is {:.5f}, which is bigger then the tolerance of {:.5f}".format(actual, expected, err['rms'], tol))
+                    raise SkipTest("Error between {} and {} is {:.5f}, which is bigger then the tolerance of {:.5f}".format(actual, expected, err['rms'], tol))
             yield do_test
     plt.close('all')
 
 def test_figure():
     np.random.seed(1239847)
     from GPy.plotting import plotting_library as pl
-    import matplotlib
+    #import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     import warnings
     with warnings.catch_warnings():
@@ -160,9 +173,9 @@ def test_figure():
 
 def test_kernel():
     np.random.seed(1239847)
-    import matplotlib
+    #import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     import warnings
     with warnings.catch_warnings():
@@ -185,7 +198,7 @@ def test_plot():
     np.random.seed(111)
     import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     import warnings
     with warnings.catch_warnings():
@@ -212,7 +225,7 @@ def test_twod():
     np.random.seed(11111)
     import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     X = np.random.uniform(-2, 2, (40, 2))
     f = .2 * np.sin(1.3*X[:,[0]]) + 1.3*np.cos(2*X[:,[1]])
@@ -235,7 +248,7 @@ def test_threed():
     np.random.seed(11111)
     import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     X = np.random.uniform(-2, 2, (40, 2))
     f = .2 * np.sin(1.3*X[:,[0]]) + 1.3*np.cos(2*X[:,[1]])
@@ -260,7 +273,7 @@ def test_sparse():
     np.random.seed(11111)
     import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #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)
@@ -276,7 +289,7 @@ def test_classification():
     np.random.seed(11111)
     import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #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)
@@ -300,7 +313,7 @@ def test_sparse_classification():
     np.random.seed(11111)
     import matplotlib
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #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)
@@ -321,7 +334,7 @@ def test_gplvm():
     from ..models import GPLVM
     np.random.seed(12345)
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     Q = 3
     # Define dataset
@@ -360,7 +373,7 @@ def test_bayesian_gplvm():
     from ..models import BayesianGPLVM
     np.random.seed(12345)
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
-    matplotlib.rcParams[u'figure.figsize'] = (4,3)
+    #matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     Q = 3
     # Define dataset
@@ -398,4 +411,4 @@ def test_bayesian_gplvm():
 
 if __name__ == '__main__':
     import nose
-    nose.main()
+    nose.main(defaultTest='./plotting_tests.py')

GPy/testing/state_space_main_tests.py

@@ -0,0 +1,977 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015, Alex Grigorevskiy
+# Licensed under the BSD 3-clause license (see LICENSE.txt)
+"""
+Test module for state_space_main.py
+"""
+
+import unittest
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.stats import norm
+
+import GPy.models.state_space_setup as ss_setup
+import GPy.models.state_space_main as ssm
+
+def generate_x_points(points_num=100, x_interval = (0, 20), random=True):
+    """
+    Function generates (sorted) points on the x axis.
+    
+    Input:
+    ---------------------------
+        points_num: int
+            How many points to generate
+        x_interval: tuple (a,b)
+            On which interval to generate points
+        random: bool
+            Regular points or random
+    
+    Output:
+    ---------------------------
+        x_points: np.array
+            Generated points
+    """
+    
+    x_interval = np.asarray( x_interval )
+
+    if random:
+        x_points = np.random.rand(points_num) * ( x_interval[1] - x_interval[0] ) + x_interval[0]
+        x_points = np.sort( x_points )
+    else:
+        x_points = np.linspace(x_interval[0], x_interval[1], num=points_num )        
+
+    return x_points
+
+def generate_sine_data(x_points=None, sin_period=2.0, sin_ampl=10.0, noise_var=2.0,
+                        plot = False, points_num=100, x_interval = (0, 20), random=True):
+    """
+    Function generates sinusoidal data.
+    
+    Input:
+    --------------------------------
+    
+    x_points: np.array
+        Previously generated X points
+    sin_period: float
+        Sine period    
+    sin_ampl: float
+        Sine amplitude
+    noise_var: float 
+        Gaussian noise variance added to the sine function
+    plot: bool
+        Whether to plot generated data
+    
+    (if x_points is None, the the following parameters are used to generate
+    those. They are the same as in 'generate_x_points' function)        
+    
+    points_num: int
+    
+    x_interval: tuple (a,b)
+    
+    random: bool
+    """    
+    
+    sin_function = lambda xx: sin_ampl * np.sin( 2*np.pi/sin_period * xx )
+    
+    if x_points is None:
+        x_points = generate_x_points(points_num, x_interval, random)
+
+    y_points = sin_function( x_points ) + np.random.randn( len(x_points) ) * np.sqrt(noise_var)
+
+    if plot:
+        pass
+    
+    return x_points, y_points
+    
+def generate_linear_data(x_points=None, tangent=2.0, add_term=1.0, noise_var=2.0,
+                        plot = False, points_num=100, x_interval = (0, 20), random=True):
+    """
+    Function generates linear data.
+    
+    Input:
+    --------------------------------
+    
+    x_points: np.array
+        Previously generated X points
+    tangent: float
+        Factor with which independent variable is multiplied in linear equation.
+    add_term: float
+        Additive term in linear equation.
+    noise_var: float 
+        Gaussian noise variance added to the sine function
+    plot: bool
+        Whether to plot generated data
+    
+    (if x_points is None, the the following parameters are used to generate
+    those. They are the same as in 'generate_x_points' function)        
+    
+    points_num: int
+    
+    x_interval: tuple (a,b)
+    
+    random: bool
+    """    
+    
+    linear_function = lambda xx:  tangent*xx + add_term
+    
+    if x_points is None:
+        x_points = generate_x_points(points_num, x_interval, random)
+
+    y_points = linear_function( x_points ) + np.random.randn( len(x_points) ) * np.sqrt(noise_var)
+
+    if plot:
+        pass
+    
+    return x_points, y_points
+
+def generate_brownian_data(x_points=None, kernel_var = 2.0, noise_var = 2.0,
+                        plot = False, points_num=100, x_interval = (0, 20), random=True):
+    """
+    Generate brownian data - data from Brownian motion.
+    First point is always 0, and \Beta(0) = 0  - standard conditions for Brownian motion.           
+           
+    Input:
+    --------------------------------
+    
+    x_points: np.array
+        Previously generated X points
+    variance: float 
+        Gaussian noise variance added to the sine function
+    plot: bool
+        Whether to plot generated data
+    
+    (if x_points is None, the the following parameters are used to generate
+    those. They are the same as in 'generate_x_points' function)        
+    
+    points_num: int
+    
+    x_interval: tuple (a,b)
+    
+    random: bool
+      
+    """    
+    if x_points is None:
+        x_points = generate_x_points(points_num, x_interval, random)
+        if x_points[0] != 0:
+            x_points[0] = 0
+    
+    y_points = np.zeros( (points_num,) )
+    for i in range(1, points_num):
+        noise = np.random.randn() * np.sqrt(kernel_var * (x_points[i] - x_points[i-1]))
+        y_points[i] = y_points[i-1] + noise
+    
+    y_points += np.random.randn( len(x_points) ) * np.sqrt(noise_var)
+    
+    return x_points, y_points   
+        
+def generate_linear_plus_sin(x_points=None, tangent=2.0, add_term=1.0, noise_var=2.0,
+                             sin_period=2.0, sin_ampl=10.0, plot = False, 
+                             points_num=100, x_interval = (0, 20), random=True):
+    """
+    Generate the sum of linear trend and the sine function.
+    
+    For parameters see the 'generate_linear' and 'generate_sine'.
+    
+    Comment: Gaussian noise variance is added only once (for linear function).
+    """
+
+    x_points, y_linear_points = generate_linear_data(x_points, tangent, add_term, noise_var,
+                        False, points_num, x_interval, random)
+                        
+    x_points, y_sine_points = generate_sine_data(x_points, sin_period, sin_ampl, 0.0,
+                        False, points_num, x_interval, random)
+
+    y_points = y_linear_points + y_sine_points
+
+    if plot:
+        pass
+        
+    return x_points, y_points
+
+def generate_random_y_data(samples, dim, ts_no):
+    """
+    Generate data:
+        
+    Input:
+    ------------------
+    
+    samples - how many samples
+    dim - dimensionality of the data
+    ts_no - number of time series
+    
+    Output:
+    --------------------------
+        Y: np.array((samples, dim, ts_no))
+    """
+    
+    Y = np.empty((samples, dim, ts_no));
+    
+    for i in range(0,samples):
+        for j in range(0,ts_no):
+            sample = np.random.randn(dim)
+            Y[i,:,j] = sample
+    
+    if (Y.shape[2] == 1): # ts_no = 1
+        Y.shape=(Y.shape[0], Y.shape[1])
+    return Y
+
+
+class StateSpaceKernelsTests(np.testing.TestCase):
+    def setUp(self):
+        pass
+    
+    def run_descr_model(self, measurements, A,Q,H,R, true_states=None, 
+                          mean_compare_decimal=8,
+                          m_init=None, P_init=None, dA=None,dQ=None,
+                          dH=None,dR=None, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True):
+                      
+            #import pdb; pdb.set_trace()
+                      
+            state_dim = 1 if not isinstance(A,np.ndarray) else A.shape[0]
+            ts_no = 1 if (len(measurements.shape) < 3) else measurements.shape[2]
+            grad_params_no = None if dA is None else dA.shape[2]
+            
+            
+            ss_setup.use_cython = use_cython
+            global ssm
+            if (ssm.cython_code_available) and (ssm.use_cython != use_cython):
+                reload(ssm)                      
+                      
+            grad_calc_params = None                      
+            if calc_grad_log_likelihood:
+                grad_calc_params = {}
+                grad_calc_params['dA'] = dA
+                grad_calc_params['dQ'] = dQ
+                grad_calc_params['dH'] = dH
+                grad_calc_params['dR'] = dR
+            
+            (f_mean, f_var, loglikelhood, g_loglikelhood, \
+             dynamic_callables_smoother) = ssm.DescreteStateSpace.kalman_filter(A, Q, H, R, measurements, index=None, 
+                m_init=m_init, P_init=P_init, p_kalman_filter_type = kalman_filter_type,
+                calc_log_likelihood=calc_log_likelihood,
+                calc_grad_log_likelihood=calc_grad_log_likelihood,
+                grad_params_no=grad_params_no,
+                grad_calc_params=grad_calc_params)
+            
+            f_mean_squeezed = np.squeeze(f_mean[1:,:]) # exclude initial value
+            f_var_squeezed = np.squeeze(f_var[1:,:]) # exclude initial value
+        
+            if true_states is not None:
+                #print np.max(np.abs(f_mean_squeezed-true_states))
+                np.testing.assert_almost_equal(np.max(np.abs(f_mean_squeezed- \
+                                true_states)), 0, decimal=mean_compare_decimal)
+           
+            np.testing.assert_equal(f_mean.shape, (measurements.shape[0]+1,state_dim,ts_no) )
+            np.testing.assert_equal(f_var.shape, (measurements.shape[0]+1,state_dim,state_dim) )
+           
+            (M_smooth, P_smooth) = ssm.DescreteStateSpace.rts_smoother(state_dim, dynamic_callables_smoother, f_mean, 
+                          f_var)           
+            
+            return f_mean, f_var
+            
+    def run_continuous_model(self, F, L, Qc, p_H, p_R, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=None, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=0, grad_calc_params=None):
+                      
+        #import pdb; pdb.set_trace()
+                      
+        state_dim = 1 if not isinstance(F,np.ndarray) else F.shape[0]
+        ts_no = 1 if (len(Y_data.shape) < 3) else Y_data.shape[2]
+
+        ss_setup.use_cython = use_cython
+        global ssm
+        if (ssm.cython_code_available) and (ssm.use_cython != use_cython):
+            reload(ssm)                      
+    
+        (f_mean, f_var, loglikelhood, g_loglikelhood, \
+         dynamic_callables_smoother) = ssm.ContDescrStateSpace.cont_discr_kalman_filter(F, L, Qc, p_H, p_R,
+                             P_inf, X_data, Y_data, index = None, 
+                             m_init=None, P_init=None, 
+                             p_kalman_filter_type='regular',
+                             calc_log_likelihood=False, 
+                             calc_grad_log_likelihood=False, 
+                             grad_params_no=0, grad_calc_params=grad_calc_params)
+        
+        f_mean_squeezed = np.squeeze(f_mean[1:,:]) # exclude initial value
+        f_var_squeezed = np.squeeze(f_var[1:,:]) # exclude initial value
+    
+        np.testing.assert_equal(f_mean.shape, (Y_data.shape[0]+1,state_dim,ts_no))
+        np.testing.assert_equal(f_var.shape, (Y_data.shape[0]+1,state_dim,state_dim))
+        
+        (M_smooth, P_smooth) = ssm.ContDescrStateSpace.cont_discr_rts_smoother(state_dim, f_mean, \
+                      f_var,dynamic_callables_smoother)           
+        
+        return f_mean, f_var
+            
+    def test_discrete_ss_first(self,plot=False):
+        """
+        Tests discrete State-Space model - first test.
+        """
+        np.random.seed(235) # seed the random number generator
+    
+        A = 1.0 # For cython code to run properly need float input
+        H = 1.0
+        Q = 1.0        
+        R = 1.0
+        
+        steps_num = 100
+        
+        # generate data ->
+        true_states = np.zeros((steps_num,))
+        init_state = 0
+        measurements = np.zeros((steps_num,))
+        
+        for s in range(0, steps_num):
+            if s== 0:
+                true_states[0] = init_state + np.sqrt(Q)*np.random.randn()
+            else:
+                true_states[s] = true_states[s-1] + np.sqrt(R)*np.random.randn()
+            measurements[s] = true_states[s] + np.sqrt(R)*np.random.randn()
+        # generate data <-
+        
+        # descrete kalman filter ->
+        m_init = 0; P_init = 1  
+        d_num = 1000
+        state_discr = np.linspace(-10,10,d_num)
+        
+        state_trans_matrix = np.empty((d_num,d_num))
+        for i in range(d_num):
+            state_trans_matrix[:,i] = norm.pdf(state_discr, loc=A*state_discr[i], scale=np.sqrt(Q))
+        
+        m_prev = norm.pdf(state_discr, loc = m_init, scale = np.sqrt(P_init)); #m_prev / np.sum(m_prev)
+        m = np.zeros((d_num, steps_num))
+        i_mean = np.zeros((steps_num,))
+        
+        for s in range(0, steps_num):
+            # Prediction step:
+            if (s==0):
+                m[:,s] =  np.dot(state_trans_matrix, m_prev)
+            else:
+                m[:,s] =  np.dot(state_trans_matrix, m[:,s-1])
+            # Update step:
+            #meas_ind = np.argmin(np.abs(state_discr - measurements[s])
+            y_vec = np.zeros( (d_num,))
+            for i in range(d_num):
+                y_vec[i] = norm.pdf(measurements[s], loc=H*state_discr[i], scale=np.sqrt(R))
+            norm_const = np.dot( y_vec, m[:,s] )
+            m[:,s] =  y_vec * m[:,s] / norm_const   
+            
+            i_mean[s] = state_discr[ np.argmax(m[:,s]) ]   
+        # descrete kalman filter <-
+        
+        (f_mean, f_var) = self.run_descr_model(measurements, A,Q,H,R, true_states=i_mean, 
+                          mean_compare_decimal=1,
+                          m_init=m_init, P_init=P_init,use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=False)
+        
+        (f_mean, f_var) = self.run_descr_model(measurements, A,Q,H,R, true_states=i_mean, 
+                          mean_compare_decimal=1,
+                          m_init=m_init, P_init=P_init,use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=False)
+                          
+        (f_mean, f_var) = self.run_descr_model(measurements, A,Q,H,R, true_states=i_mean, 
+                          mean_compare_decimal=1,
+                          m_init=m_init, P_init=P_init,use_cython=True,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=False)
+                          
+        if plot:
+            # plotting ->
+            plt.figure()
+            plt.plot( true_states, 'g.-',label='true states')
+            #plt.plot( measurements, 'b.-', label='measurements')
+            plt.plot( f_mean, 'r.-',label='Kalman filter estimates')
+            plt.plot( i_mean, 'k.-', label='Discretization')
+            
+            plt.plot( f_mean + 2*np.sqrt(f_var), 'r.--')
+            plt.plot( f_mean - 2*np.sqrt(f_var), 'r.--')
+            plt.legend()
+            plt.show()
+            # plotting <-
+        return None
+        
+    def test_discrete_ss_1D(self,plot=False):
+        """
+        This function tests Kalman filter and smoothing when the state 
+        dimensionality is one dimensional.
+        """        
+        
+        np.random.seed(234) # seed the random number generator
+    
+        # 1D ss model    
+        state_dim = 1; 
+        param_num = 2 # sigma_Q, sigma_R - parameters
+        measurement_dim = 1 # dimensionality od measurement    
+        
+        A = 1.0
+        Q = 2.0
+        dA= np.zeros((state_dim,state_dim,param_num))
+        dQ = np.zeros((state_dim,state_dim,param_num)); dQ[0,0,0] = 1.0
+        
+        # measurement related parameters (subject to change) ->
+        H = np.ones((measurement_dim,state_dim ))
+        R = 0.5 * np.eye(measurement_dim)    
+        dH = np.zeros((measurement_dim,state_dim,param_num))
+        dR = np.zeros((measurement_dim,measurement_dim,param_num)); dR[:,:,1] = np.eye(measurement_dim)
+        # measurement related parameters (subject to change) <-
+    
+         # 1D measurement, 1 ts_no ->
+        data = generate_random_y_data(10, 1, 1) # np.array((samples, dim, ts_no))
+    
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+                                            
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)                              
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=True,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+            
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( np.squeeze(data), 'g.-', label='measurements')
+            plt.plot( np.squeeze(f_mean[1:]), 'b.-',label='Kalman filter estimates')
+            plt.plot( np.squeeze(f_mean[1:]+H*f_var[1:]*H), 'b--')
+            plt.plot( np.squeeze(f_mean[1:]-H*f_var[1:]*H), 'b--')
+#            plt.plot( np.squeeze(M_sm[1:]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:]+H*P_sm[1:]*H), 'r--')
+#            plt.plot( np.squeeze(M_sm[1:]-H*P_sm[1:]*H), 'r--')
+            plt.legend()
+            plt.title("1D state-space, 1D measurements, 1 ts_no")
+            plt.show()
+            # plotting <-
+        # 1D measurement, 1 ts_no <-
+        
+        
+        # 1D measurement, 3 ts_no ->
+        data = generate_random_y_data(10, 1, 3) # np.array((samples, dim, ts_no))
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+                                            
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)                              
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=True,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+       
+        #import pdb; pdb.set_trace()
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( np.squeeze(data[:,:,1]), 'g.-', label='measurements')
+            plt.plot( np.squeeze(f_mean[1:,0,1]), 'b.-',label='Kalman filter estimates')
+            plt.plot( np.squeeze(f_mean[1:,0,1])+np.squeeze(H*f_var[1:]*H), 'b--')
+            plt.plot( np.squeeze(f_mean[1:,0,1])-np.squeeze(H*f_var[1:]*H), 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])+H*np.squeeze(P_sm[1:])*H, 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])-H*np.squeeze(P_sm[1:])*H, 'r--')
+            plt.legend()
+            plt.title("1D state-space, 1D measurements, 3 ts_no. 2-nd ts ploted")
+            plt.show()
+            # plotting <-
+        # 1D measurement, 3 ts_no <-        
+        measurement_dim = 2 # dimensionality of measurement 
+    
+        H = np.ones((measurement_dim,state_dim))
+        R = 0.5 * np.eye(measurement_dim)    
+        dH = np.zeros((measurement_dim,state_dim,param_num))
+        dR = np.zeros((measurement_dim,measurement_dim,param_num)); dR[:,:,1] = np.eye(measurement_dim)
+        # measurement related parameters (subject to change) <
+        
+        data = generate_random_y_data(10, 2, 3) # np.array((samples, dim, ts_no))
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+                                            
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)                              
+        
+#        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+#                          mean_compare_decimal=16,
+#                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+#                          dH=dH,dR=dR, use_cython=True,
+#                          kalman_filter_type='svd',
+#                          calc_log_likelihood=True,
+#                          calc_grad_log_likelihood=True)
+        
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( np.squeeze(data[:,0,1]), 'g.-', label='measurements')
+            plt.plot( np.squeeze(f_mean[1:,0,1]), 'b.-',label='Kalman filter estimates')
+            plt.plot( np.squeeze(f_mean[1:,0,1])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot( np.squeeze(f_mean[1:,0,1])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("1D state-space, 2D measurements, 3 ts_no. 1-st measurement, 2-nd ts ploted")
+            plt.show()
+            # plotting <-
+        # 2D measurement, 3 ts_no <-
+            
+    def test_discrete_ss_2D(self,plot=False):
+        """
+        This function tests Kalman filter and smoothing when the state 
+        dimensionality is two dimensional.
+        """   
+
+        np.random.seed(234) # seed the random number generator
+    
+        # 1D ss model    
+        state_dim = 2; 
+        param_num = 3 # sigma_Q, sigma_R, one parameters in A - parameters
+        measurement_dim = 1 # dimensionality od measurement    
+        
+        A = np.eye(state_dim); A[0,0] = 0.5
+        Q = np.ones((state_dim,state_dim));
+        dA = np.zeros((state_dim,state_dim,param_num)); dA[1,1,2] = 1
+        dQ = np.zeros((state_dim,state_dim,param_num)); dQ[:,:,1] = np.eye(measurement_dim)
+        
+        # measurement related parameters (subject to change) ->
+        H = np.ones((measurement_dim,state_dim))
+        R = 0.5 * np.eye(measurement_dim)    
+        dH = np.zeros((measurement_dim,state_dim,param_num))
+        dR = np.zeros((measurement_dim,measurement_dim,param_num)); dR[:,:,1] = np.eye(measurement_dim)
+        # measurement related parameters (subject to change) <-
+
+        # 1D measurement, 1 ts_no ->
+        data = generate_random_y_data(10, 1, 1) # np.array((samples, dim, ts_no))
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+                                            
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)                              
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=True,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( np.squeeze(data), 'g.-', label='measurements')
+            plt.plot( np.squeeze(f_mean[1:,0]), 'b.-',label='Kalman filter estimates')
+            plt.plot( np.squeeze(f_mean[1:,0])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot( np.squeeze(f_mean[1:,0])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,0]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,0])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,0])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("2D state-space, 1D measurements, 1 ts_no")
+            plt.show()
+            # plotting <-
+        # 1D measurement, 1 ts_no <-
+        
+        # 1D measurement, 3 ts_no ->
+        data = generate_random_y_data(10, 1, 3) # np.array((samples, dim, ts_no))
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+                                            
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)                              
+        
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=True,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)        
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( np.squeeze(data[:,:,1]), 'g.-', label='measurements')
+            plt.plot( np.squeeze(f_mean[1:,0,1]), 'b.-',label='Kalman filter estimates')
+            plt.plot( np.squeeze(f_mean[1:,0,1])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot( np.squeeze(f_mean[1:,0,1])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("2D state-space, 1D measurements, 3 ts_no. 2-nd ts ploted")
+            plt.show()
+            # plotting <-
+        # 1D measurement, 3 ts_no <-
+            
+        # 2D measurement, 3 ts_no ->
+        # measurement related parameters (subject to change) ->
+        measurement_dim = 2 # dimensionality od measurement 
+        
+        H = np.ones((measurement_dim,state_dim))
+        R = 0.5 * np.eye(measurement_dim)    
+        dH = np.zeros((measurement_dim,state_dim,param_num))
+        dR = np.zeros((measurement_dim,measurement_dim,param_num)); dR[:,:,1] = np.eye(measurement_dim)
+        # measurement related parameters (subject to change) <
+        
+        data = generate_random_y_data(10, 2, 3) # np.array((samples, dim, ts_no))
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)
+                                            
+        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+                          mean_compare_decimal=16,
+                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+                          dH=dH,dR=dR, use_cython=False,
+                          kalman_filter_type='svd',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True)                              
+        
+#        (f_mean, f_var) = self.run_descr_model(data, A,Q,H,R, true_states=None,
+#                          mean_compare_decimal=16,
+#                          m_init=None, P_init=None, dA=dA,dQ=dQ,
+#                          dH=dH,dR=dR, use_cython=True,
+#                          kalman_filter_type='svd',
+#                          calc_log_likelihood=True,
+#                          calc_grad_log_likelihood=True)  
+                          
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( np.squeeze(data[:,0,1]), 'g.-', label='measurements')
+            plt.plot( np.squeeze(f_mean[1:,0,1]), 'b.-',label='Kalman filter estimates')
+            plt.plot( np.squeeze(f_mean[1:,0,1])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot( np.squeeze(f_mean[1:,0,1])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,0,1])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("2D state-space, 2D measurements, 3 ts_no. 1-st measurement, 2-nd ts ploted")
+            plt.show()
+            # plotting <-
+        # 2D measurement, 3 ts_no <-
+            
+    def test_continuos_ss(self,plot=False):
+        """
+        This function tests the continuos state-space model.
+        """                    
+                
+        # 1D measurements, 1 ts_no ->
+        measurement_dim = 1 # dimensionality of measurement 
+        
+        X_data = generate_x_points(points_num=10, x_interval = (0, 20), random=True)
+        Y_data = generate_random_y_data(10, 1, 1) # np.array((samples, dim, ts_no))
+        
+        try:
+            import GPy
+        except ImportError as e:
+            return None
+        
+        periodic_kernel = GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+        (F,L,Qc,H,P_inf,P0, dFt,dQct,dP_inft,dP0) = periodic_kernel.sde()    
+        
+        state_dim = dFt.shape[0]; 
+        param_num = dFt.shape[2]
+    
+    
+        grad_calc_params = {}
+        grad_calc_params['dP_inf'] = dP_inft
+        grad_calc_params['dF'] = dFt
+        grad_calc_params['dQc'] = dQct
+        grad_calc_params['dR'] = np.zeros((measurement_dim,measurement_dim,param_num))
+        grad_calc_params['dP_init'] = dP0
+        # dH matrix is None    
+        
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, 1.5, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+                          
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, 1.5, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=False,
+                          kalman_filter_type='rbc',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+        
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, 1.5, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=True,
+                          kalman_filter_type='rbc',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+                                    
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot( X_data, np.squeeze(Y_data[:,0]), 'g.-', label='measurements')
+            plt.plot( X_data, np.squeeze(f_mean[1:,15]), 'b.-',label='Kalman filter estimates')
+            plt.plot( X_data, np.squeeze(f_mean[1:,15])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot( X_data, np.squeeze(f_mean[1:,15])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+    #        plt.plot( np.squeeze(M_sm[1:,15]), 'r.-',label='Smoother Estimates')
+    #        plt.plot( np.squeeze(M_sm[1:,15])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+    #        plt.plot( np.squeeze(M_sm[1:,15])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("1D measurements, 1 ts_no")
+            plt.show()
+            # plotting <-
+        # 1D measurements, 1 ts_no <-        
+        
+        # 1D measurements, 3 ts_no ->
+        measurement_dim = 1 # dimensionality od measurement 
+        
+        X_data = generate_x_points(points_num=10, x_interval = (0, 20), random=True)
+        Y_data = generate_random_y_data(10, 1, 3) # np.array((samples, dim, ts_no))
+        
+        periodic_kernel = GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+        (F,L,Qc,H,P_inf,P0, dFt,dQct,dP_inft,dP0) = periodic_kernel.sde()    
+        
+        state_dim = dFt.shape[0]; 
+        param_num = dFt.shape[2]
+        
+        grad_calc_params = {}
+        grad_calc_params['dP_inf'] = dP_inft
+        grad_calc_params['dF'] = dFt
+        grad_calc_params['dQc'] = dQct
+        grad_calc_params['dR'] = np.zeros((measurement_dim,measurement_dim,param_num))
+        grad_calc_params['dP_init'] = dP0
+        # dH matrix is None    
+        
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, 1.5, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+                          
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, 1.5, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=False,
+                          kalman_filter_type='rbc',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+        
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, 1.5, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=True,
+                          kalman_filter_type='rbc',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+                          
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot(X_data, np.squeeze(Y_data[:,0,1]), 'g.-', label='measurements')
+            plt.plot(X_data, np.squeeze(f_mean[1:,15,1]), 'b.-',label='Kalman filter estimates')
+            plt.plot(X_data, np.squeeze(f_mean[1:,15,1])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot(X_data, np.squeeze(f_mean[1:,15,1])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,15,1]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,15,1])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,15,1])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("1D measurements, 3 ts_no. 2-nd ts ploted")
+            plt.show()
+            # plotting <-
+        # 1D measurements, 3 ts_no <-        
+        
+        
+        # 2D measurements, 3 ts_no ->
+        measurement_dim = 2 # dimensionality od measurement 
+        
+        X_data = generate_x_points(points_num=10, x_interval = (0, 20), random=True)
+        Y_data = generate_random_y_data(10, 2, 3) # np.array((samples, dim, ts_no))
+        
+        periodic_kernel = GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+        (F,L,Qc,H,P_inf,P0, dFt,dQct,dP_inft,dP0) = periodic_kernel.sde()    
+        H = np.vstack((H,H)) # make 2D measurements    
+        R = 1.5 * np.eye(measurement_dim)    
+        
+        state_dim = dFt.shape[0]; 
+        param_num = dFt.shape[2]
+        
+        
+        grad_calc_params = {}
+        grad_calc_params['dP_inf'] = dP_inft
+        grad_calc_params['dF'] = dFt
+        grad_calc_params['dQc'] = dQct
+        grad_calc_params['dR'] = np.zeros((measurement_dim,measurement_dim,param_num))
+        grad_calc_params['dP_init'] = dP0
+        # dH matrix is None    
+        
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, R, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=False,
+                          kalman_filter_type='regular',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+                          
+        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, R, P_inf, X_data, Y_data, index = None,  
+                          m_init=None, P_init=P0, use_cython=False,
+                          kalman_filter_type='rbc',
+                          calc_log_likelihood=True,
+                          calc_grad_log_likelihood=True,
+                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+        
+#        (f_mean, f_var) = self.run_continuous_model(F, L, Qc, H, R, P_inf, X_data, Y_data, index = None,  
+#                          m_init=None, P_init=P0, use_cython=True,
+#                          kalman_filter_type='rbc',
+#                          calc_log_likelihood=True,
+#                          calc_grad_log_likelihood=True,
+#                          grad_params_no=param_num, grad_calc_params=grad_calc_params)
+                                    
+        if plot:    
+            # plotting ->
+            plt.figure()
+            plt.plot(X_data, np.squeeze(Y_data[:,0,1]), 'g.-', label='measurements')
+            plt.plot(X_data, np.squeeze(f_mean[1:,15,1]), 'b.-',label='Kalman filter estimates')
+            plt.plot(X_data, np.squeeze(f_mean[1:,15,1])+np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+            plt.plot(X_data, np.squeeze(f_mean[1:,15,1])-np.einsum('ij,ajk,kl', H, f_var[1:], H.T)[:,0,0], 'b--')
+#            plt.plot( np.squeeze(M_sm[1:,15,1]), 'r.-',label='Smoother Estimates')
+#            plt.plot( np.squeeze(M_sm[1:,15,1])+np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+#            plt.plot( np.squeeze(M_sm[1:,15,1])-np.einsum('ij,ajk,kl', H, P_sm[1:], H.T)[:,0,0], 'r--')
+            plt.legend()
+            plt.title("1D measurements, 3 ts_no. 2-nd ts ploted")
+            plt.show()
+            # plotting <-
+        # 2D measurements, 3 ts_no <-        
+                
+#def test_EM_gradient(plot=False):
+#    """
+#    Test EM gradient calculation. This method works (the formulas are such)
+#    that it works only for time invariant matrices A, Q, H, R. For the continuous
+#    model it means that time intervals are the same.
+#    """    
+#    
+#    np.random.seed(234) # seed the random number generator
+#    
+#    # 1D measurements, 1 ts_no ->
+#    measurement_dim = 1 # dimensionality of measurement 
+#    
+#    x_data = generate_x_points(points_num=10, x_interval = (0, 20), random=False)
+#    data = generate_random_y_data(10, 1, 1) # np.array((samples, dim, ts_no))
+#    
+#    import GPy
+#    #periodic_kernel = GPy.kern.sde_Matern32(1,active_dims=[0,])
+#    periodic_kernel = GPy.kern.sde_StdPeriodic(1,active_dims=[0,])
+#    (F,L,Qc,H,P_inf,P0, dFt,dQct,dP_inft,dP0t) = periodic_kernel.sde()    
+#    
+#    state_dim = dFt.shape[0]; 
+#    param_num = dFt.shape[2]
+#    
+#    grad_calc_params = {}
+#    grad_calc_params['dP_inf'] = dP_inft
+#    grad_calc_params['dF'] = dFt
+#    grad_calc_params['dQc'] = dQct
+#    grad_calc_params['dR'] = np.zeros((measurement_dim,measurement_dim,param_num))
+#    grad_calc_params['dP_init'] = dP0t
+#    # dH matrix is None    
+#    
+#
+#    #(F,L,Qc,H,P_inf,dF,dQc,dP_inf) = ssm.balance_ss_model(F,L,Qc,H,P_inf,dF,dQc,dP_inf)
+#    # Use the Kalman filter to evaluate the likelihood
+#    
+#    #import pdb; pdb.set_trace()
+#    (M_kf, P_kf, log_likelihood, 
+#     grad_log_likelihood,SmootherMatrObject) = ss.ContDescrStateSpace.cont_discr_kalman_filter(F,
+#                                  L, Qc, H, 1.5, P_inf, x_data, data, m_init=None,
+#                                  P_init=P0, calc_log_likelihood=True, 
+#                                  calc_grad_log_likelihood=True, 
+#                                  grad_params_no=param_num, 
+#                                  grad_calc_params=grad_calc_params)
+#                                                                    
+#    if plot:    
+#        # plotting ->
+#        plt.figure()
+#        plt.plot( np.squeeze(data[:,0]), 'g.-', label='measurements')
+#        plt.plot( np.squeeze(M_kf[1:,15]), 'b.-',label='Kalman filter estimates')
+#        plt.plot( np.squeeze(M_kf[1:,15])+np.einsum('ij,ajk,kl', H, P_kf[1:], H.T)[:,0,0], 'b--')
+#        plt.plot( np.squeeze(M_kf[1:,15])-np.einsum('ij,ajk,kl', H, P_kf[1:], H.T)[:,0,0], 'b--')
+#        plt.title("1D measurements, 1 ts_no")
+#        plt.show()
+#        # plotting <-
+#    # 1D measurements, 1 ts_no <-
+    
+if __name__ == '__main__':
+    print("Running state-space inference tests...")
+    unittest.main()
+    
+    #tt = StateSpaceKernelsTests('test_discrete_ss_first')
+    #res = tt.test_discrete_ss_first(plot=True)    
+    #res = tt.test_discrete_ss_1D(plot=True)        
+    #res = tt.test_discrete_ss_2D(plot=False) 
+    #res = tt.test_continuos_ss(plot=True)
+    
+ 

GPy/testing/util_tests.py

@@ -0,0 +1,98 @@
+#===============================================================================
+# Copyright (c) 2016, Max Zwiessele, Alan Saul
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# 
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# 
+# * Neither the name of GPy.testing.util_tests nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# 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 unittest, numpy as np
+
+class TestDebug(unittest.TestCase):
+    def test_checkFinite(self):
+        from GPy.util.debug import checkFinite
+        array = np.random.normal(0, 1, 100).reshape(25,4)
+        self.assertTrue(checkFinite(array, name='test'))
+        
+        array[np.random.binomial(1, .3, array.shape).astype(bool)] = np.nan
+        self.assertFalse(checkFinite(array))
+
+    def test_checkFullRank(self):
+        from GPy.util.debug import checkFullRank
+        from GPy.util.linalg import tdot
+        array = np.random.normal(0, 1, 100).reshape(25,4)
+        self.assertFalse(checkFullRank(tdot(array), name='test'))
+        
+        array = np.random.normal(0, 1, (25,25))
+        self.assertTrue(checkFullRank(tdot(array)))
+    
+    def test_fixed_inputs_median(self):
+        """ test fixed_inputs convenience function """
+        from GPy.plotting.matplot_dep.util import fixed_inputs
+        import GPy
+        X = np.random.randn(10, 3)
+        Y = np.sin(X) + np.random.randn(10, 3)*1e-3
+        m = GPy.models.GPRegression(X, Y)
+        fixed = fixed_inputs(m, [1], fix_routine='median', as_list=True, X_all=False)
+        self.assertTrue((0, np.median(X[:,0])) in fixed)
+        self.assertTrue((2, np.median(X[:,2])) in fixed)
+        self.assertTrue(len([t for t in fixed if t[0] == 1]) == 0) # Unfixed input should not be in fixed
+
+    def test_fixed_inputs_mean(self):
+        from GPy.plotting.matplot_dep.util import fixed_inputs
+        import GPy
+        X = np.random.randn(10, 3)
+        Y = np.sin(X) + np.random.randn(10, 3)*1e-3
+        m = GPy.models.GPRegression(X, Y)
+        fixed = fixed_inputs(m, [1], fix_routine='mean', as_list=True, X_all=False)
+        self.assertTrue((0, np.mean(X[:,0])) in fixed)
+        self.assertTrue((2, np.mean(X[:,2])) in fixed)
+        self.assertTrue(len([t for t in fixed if t[0] == 1]) == 0) # Unfixed input should not be in fixed
+
+    def test_fixed_inputs_zero(self):
+        from GPy.plotting.matplot_dep.util import fixed_inputs
+        import GPy
+        X = np.random.randn(10, 3)
+        Y = np.sin(X) + np.random.randn(10, 3)*1e-3
+        m = GPy.models.GPRegression(X, Y)
+        fixed = fixed_inputs(m, [1], fix_routine='zero', as_list=True, X_all=False)
+        self.assertTrue((0, 0.0) in fixed)
+        self.assertTrue((2, 0.0) in fixed)
+        self.assertTrue(len([t for t in fixed if t[0] == 1]) == 0) # Unfixed input should not be in fixed
+
+    def test_fixed_inputs_uncertain(self):
+        from GPy.plotting.matplot_dep.util import fixed_inputs
+        import GPy
+        from GPy.core.parameterization.variational import NormalPosterior
+        X_mu = np.random.randn(10, 3)
+        X_var = np.random.randn(10, 3)
+        X = NormalPosterior(X_mu, X_var)
+        Y = np.sin(X_mu) + np.random.randn(10, 3)*1e-3
+        m = GPy.models.BayesianGPLVM(Y, X=X_mu, X_variance=X_var, input_dim=3)
+        fixed = fixed_inputs(m, [1], fix_routine='median', as_list=True, X_all=False)
+        self.assertTrue((0, np.median(X.mean.values[:,0])) in fixed)
+        self.assertTrue((2, np.median(X.mean.values[:,2])) in fixed)
+        self.assertTrue(len([t for t in fixed if t[0] == 1]) == 0) # Unfixed input should not be in fixed
+