From 888a1ff0f779ad1e459bfb4aa309542addfc6409 Mon Sep 17 00:00:00 2001 From: Alan Saul Date: Thu, 12 Sep 2013 10:23:51 +0100 Subject: [PATCH] Refactored tests --- GPy/testing/laplace_tests.py | 156 ++++++++++++++++++++++++++--------- 1 file changed, 119 insertions(+), 37 deletions(-) diff --git a/GPy/testing/laplace_tests.py b/GPy/testing/laplace_tests.py index 8aabe50a..2db83c25 100644 --- a/GPy/testing/laplace_tests.py +++ b/GPy/testing/laplace_tests.py @@ -22,6 +22,45 @@ def dparam_partial(inst_func, *args): return inst_func(*args) return functools.partial(param_func, inst_func=inst_func, args=args) +def grad_checker_wrt_params(func, dfunc, params, args, randomize=False, verbose=False): + """ + checkgrad expects a f: R^N -> R^1 and df: R^N -> R^N + However if we are holding other parameters fixed and moving something else + We need to check the gradient of each of the fixed parameters (f and y for example) seperately + Whilst moving another parameter. otherwise f: gives back R^N and df: gives back R^NxM where M is + The number of parameters and N is the number of data + Need to take a slice out from f and a slice out of df + """ + print "{} likelihood: {} vs {}".format(func.im_self.__class__.__name__, + func.__name__, dfunc.__name__) + partial_f = dparam_partial(func, *args) + partial_df = dparam_partial(dfunc, *args) + gradchecked = False + for param in params: + fnum = np.atleast_1d(partial_f(param)).shape[0] + dfnum = np.atleast_1d(partial_df(param)).shape[0] + for fixed_val in range(dfnum): + f_ind = min(fnum, fixed_val+1) - 1 #dlik and dlik_dvar gives back 1 value for each + grad = GradientChecker(lambda x: np.atleast_1d(partial_f(x))[f_ind], + lambda x : np.atleast_1d(partial_df(x))[fixed_val], + param, 'p') + grad.constrain_positive('p') + if randomize: + grad.randomize() + if verbose: + grad.checkgrad(verbose=1) + cg = grad.checkgrad() + print cg + if cg: + print "True" + gradchecked = True + else: + print "False" + return False + print str(gradchecked) + return gradchecked + + class LaplaceTests(unittest.TestCase): def setUp(self): self.N = 5 @@ -34,72 +73,115 @@ class LaplaceTests(unittest.TestCase): self.f = np.random.rand(self.N, 1) + self.var = 0.1 + self.stu_t = GPy.likelihoods.functions.StudentT(deg_free=5, sigma2=self.var) + self.gauss = GPy.likelihoods.functions.Gaussian(self.var, self.D, self.N) + + def tearDown(self): + self.stu_t = None + self.gauss = None + def test_gaussian_dlik_df(self): - var = 0.1 - gauss = GPy.likelihoods.functions.Gaussian(var, self.D, self.N) - link = functools.partial(gauss.link_function, self.Y) - dlik_df = functools.partial(gauss.dlik_df, self.Y) + link = functools.partial(self.gauss.link_function, self.Y) + dlik_df = functools.partial(self.gauss.dlik_df, self.Y) grad = GradientChecker(link, dlik_df, self.f.copy(), 'f') grad.randomize() grad.checkgrad(verbose=1) self.assertTrue(grad.checkgrad()) def test_gaussian_d2lik_d2f(self): - var = 0.1 - gauss = GPy.likelihoods.functions.Gaussian(var, self.D, self.N) - dlik_df = functools.partial(gauss.dlik_df, self.Y) - d2lik_d2f = functools.partial(gauss.d2lik_d2f, self.Y) + dlik_df = functools.partial(self.gauss.dlik_df, self.Y) + d2lik_d2f = functools.partial(self.gauss.d2lik_d2f, self.Y) grad = GradientChecker(dlik_df, d2lik_d2f, self.f.copy(), 'f') grad.randomize() grad.checkgrad(verbose=1) self.assertTrue(grad.checkgrad()) def test_gaussian_d3lik_d3f(self): - var = 0.1 - gauss = GPy.likelihoods.functions.Gaussian(var, self.D, self.N) - d2lik_d2f = functools.partial(gauss.d2lik_d2f, self.Y) - d3lik_d3f = functools.partial(gauss.d3lik_d3f, self.Y) + d2lik_d2f = functools.partial(self.gauss.d2lik_d2f, self.Y) + d3lik_d3f = functools.partial(self.gauss.d3lik_d3f, self.Y) grad = GradientChecker(d2lik_d2f, d3lik_d3f, self.f.copy(), 'f') grad.randomize() grad.checkgrad(verbose=1) self.assertTrue(grad.checkgrad()) def test_gaussian_dlik_dvar(self): - var = 0.1 - gauss = GPy.likelihoods.functions.Gaussian(var, self.D, self.N) - - link = dparam_partial(gauss.link_function, self.Y, self.f) - dlik_dvar = dparam_partial(gauss.dlik_dvar, self.Y, self.f) - grad = GradientChecker(link, dlik_dvar, var, 'v') - grad.constrain_positive('v') - grad.randomize() - grad.checkgrad(verbose=1) + #link = dparam_partial(self.gauss.link_function, self.Y, self.f) + #dlik_dvar = dparam_partial(self.gauss.dlik_dvar, self.Y, self.f) + #grad = GradientChecker(link, dlik_dvar, self.var, 'v') + #grad.constrain_positive('v') + #grad.randomize() + #grad.checkgrad(verbose=1) #self.assertTrue(grad.checkgrad()) + self.assertTrue(grad_checker_wrt_params(self.gauss.link_function, self.gauss.dlik_dvar, + [self.var], args=(self.Y, self.f), randomize=True, verbose=True)) def test_gaussian_dlik_df_dvar(self): - var = 0.1 - gauss = GPy.likelihoods.functions.Gaussian(var, self.D, self.N) + #dlik_df = dparam_partial(self.gauss.dlik_df, self.Y, self.f) + #dlik_df_dvar = dparam_partial(self.gauss.dlik_df_dvar, self.Y, self.f) + #grad = GradientChecker(dlik_df, dlik_df_dvar, self.var, 'v') + #grad.constrain_positive('v') + #grad.randomize() + #grad.checkgrad(verbose=1) + #self.assertTrue(grad.checkgrad()) + self.assertTrue(grad_checker_wrt_params(self.gauss.dlik_df, self.gauss.dlik_df_dvar, + [self.var], args=(self.Y, self.f), randomize=True, verbose=True)) - dlik_df = dparam_partial(gauss.dlik_df, self.Y, self.f) - dlik_df_dvar = dparam_partial(gauss.dlik_df_dvar, self.Y, self.f) - grad = GradientChecker(dlik_df, dlik_df_dvar, var, 'v') - grad.constrain_positive('v') + def test_studentt_dlik_df(self): + link = functools.partial(self.stu_t.link_function, self.Y) + dlik_df = functools.partial(self.stu_t.dlik_df, self.Y) + grad = GradientChecker(link, dlik_df, self.f.copy(), 'f') + grad.randomize() + grad.checkgrad(verbose=1) + + def test_studentt_d2lik_d2f(self): + dlik_df = functools.partial(self.stu_t.dlik_df, self.Y) + d2lik_d2f = functools.partial(self.stu_t.d2lik_d2f, self.Y) + grad = GradientChecker(dlik_df, d2lik_d2f, self.f.copy(), 'f') + grad.randomize() + grad.checkgrad(verbose=1) + + def test_studentt_d3lik_d3f(self): + d2lik_d2f = functools.partial(self.stu_t.d2lik_d2f, self.Y) + d3lik_d3f = functools.partial(self.stu_t.d3lik_d3f, self.Y) + grad = GradientChecker(d2lik_d2f, d3lik_d3f, self.f.copy(), 'f') grad.randomize() grad.checkgrad(verbose=1) - #self.assertTrue(grad.checkgrad()) def test_studentt_dlik_dvar(self): - var = 0.1 - stu_t = GPy.likelihoods.functions.StudentT(deg_free=5, sigma2=var) - - link = dparam_partial(stu_t.link_function, self.Y, self.f) - dlik_dvar = dparam_partial(stu_t.dlik_dvar, self.Y, self.f) - grad = GradientChecker(link, dlik_dvar, var, 'v') - grad.constrain_positive('v') - grad.randomize() - grad.checkgrad(verbose=1) + #link = dparam_partial(self.stu_t.link_function, self.Y, self.f) + #dlik_dvar = dparam_partial(self.stu_t.dlik_dvar, self.Y, self.f) + #grad = GradientChecker(link, dlik_dvar, self.var, 'v') + #grad.constrain_positive('v') + #grad.randomize() + #grad.checkgrad(verbose=1) #self.assertTrue(grad.checkgrad()) + self.assertTrue(grad_checker_wrt_params(self.stu_t.link_function, self.stu_t.dlik_dvar, + [self.var], args=(self.Y.copy(), self.f.copy()), randomize=True, verbose=True)) + + def test_studentt_dlik_df_dvar(self): + #dlik_df = dparam_partial(self.stu_t.dlik_df, self.Y, self.f) + #dlik_df_dvar = dparam_partial(self.stu_t.dlik_df_dvar, self.Y, self.f) + #grad = GradientChecker(dlik_df, dlik_df_dvar, self.var, 'v') + #grad.constrain_positive('v') + #grad.randomize() + #grad.checkgrad(verbose=1) + #self.assertTrue(grad.checkgrad()) + self.assertTrue(grad_checker_wrt_params(self.stu_t.dlik_df, self.stu_t.dlik_df_dvar, + [self.var], args=(self.Y.copy(), self.f.copy()), randomize=True, verbose=True)) if __name__ == "__main__": + #N = 5 + #D = 1 + #X = np.linspace(0, 1, N)[:, None] + #real_std = 0.2 + #noise = np.random.randn(*X.shape)*real_std + #Y = np.sin(X*2*np.pi) + noise + #f = np.random.rand(N, 1) + #var = 0.1 + #stu_t = GPy.likelihoods.functions.StudentT(deg_free=5, sigma2=var) + + #print grad_checker_wrt_params(stu_t.dlik_df, stu_t.dlik_df_dvar, [var], args=(Y, f), randomize=True, verbose=False) + print "Running unit tests" unittest.main()