def test_can_optimize_b(self): gpm = gp.GPModel(self.N, self.K, self.dt, regression_updater='approximate') gpm.set_priors().set_inits() gpm.iterate() assert_true(~np.isnan(gpm.L())) gpm = gp.GPModel(self.N, self.K, self.dt, regression_updater='exact') gpm.set_priors().set_inits() gpm.iterate() assert_true(~np.isnan(gpm.L()))
def test_can_set_inits_no_baseline(self): gpm = gp.GPModel(self.N, self.K, self.dt, include_baseline=False) alphatest = np.random.rand(self.K, self.U) betatest = np.random.rand(self.K, self.U) gamma1test = np.random.rand(2, self.K) gamma2test = np.random.rand(2, self.K) delta1test = np.random.rand(self.K) delta2test = np.random.rand(self.K) xitest = np.random.rand(self.T, self.K) xitest_normed = xitest.copy() xitest_normed[:, 0] = 1 Xitest = np.random.rand(self.T - 1, self.K, 2, 2) gpm.set_inits(alpha=alphatest, beta=betatest, gamma1=gamma1test, gamma2=gamma2test, delta1=delta1test, delta2=delta2test, xi=xitest, Xi=Xitest) npt.assert_array_equal(gpm.alpha, alphatest) npt.assert_array_equal(gpm.beta, betatest) npt.assert_array_equal(gpm.gamma1, gamma1test) npt.assert_array_equal(gpm.gamma2, gamma2test) npt.assert_array_equal(gpm.delta1, delta1test) npt.assert_array_equal(gpm.delta2, delta2test) npt.assert_array_equal(gpm.xi, xitest) # Xi will have been normalized Xinorm = Xitest / np.sum(Xitest, axis=(-1, -2), keepdims=True) npt.assert_allclose(gpm.Xi, Xinorm) npt.assert_allclose(np.sum(gpm.Xi, axis=(-1, -2)), np.ones((self.T - 1, self.K)))
def test_no_arguments_sets_default_priors(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_priors() assert_equals(gpm.nu1.shape, (2, self.K)) assert_equals(gpm.nu2.shape, (2, self.K)) assert_equals(gpm.rho1.shape, (self.K, )) assert_equals(gpm.rho2.shape, (self.K, ))
def test_invalid_prior_shapes_raises_error(self): gpm = gp.GPModel(self.N, self.K, self.dt) assert_raises(ValueError, gpm.set_priors, nu1=np.ones((self.K + 1, self.U))) assert_raises(ValueError, gpm.set_priors, nu2=np.ones((1, self.U))) assert_raises(ValueError, gpm.set_priors, rho1=np.ones((1, self.K))) assert_raises(ValueError, gpm.set_priors, rho2=np.ones((2, self.K, 1)))
def test_cached_F_prod(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_priors().set_inits() gpm.iterate() npt.assert_allclose(gpm._Ftu, gpm.F_prod()) kk = 3 npt.assert_allclose(gpm._Ftku[:, kk, :], gpm.F_prod(kk)) npt.assert_allclose(gpm.F_prod(kk, update=True), gpm._Ftku[:, kk, :]) npt.assert_allclose(np.prod(gpm._Fpre, axis=1), gpm._Ftu)
def test_can_set_priors(self): gpm = gp.GPModel(self.N, self.K, self.dt) nu1test = np.random.rand(2, self.K) nu2test = np.random.rand(2, self.K) rho1test = np.random.rand(self.K) rho2test = np.random.rand(self.K) gpm.set_priors(nu1=nu1test, nu2=nu2test, rho1=rho1test, rho2=rho2test) npt.assert_array_equal(gpm.nu1, nu1test) npt.assert_array_equal(gpm.nu2, nu2test) npt.assert_array_equal(gpm.rho1, rho1test) npt.assert_array_equal(gpm.rho2, rho2test)
def test_no_arguments_sets_default_inits(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_inits() assert_equals(gpm.alpha.shape, (self.K, self.U)) assert_equals(gpm.beta.shape, (self.K, self.U)) assert_equals(gpm.gamma1.shape, (2, self.K)) assert_equals(gpm.gamma2.shape, (2, self.K)) assert_equals(gpm.delta1.shape, (self.K, )) assert_equals(gpm.delta2.shape, (self.K, )) assert_equals(gpm.aa.shape, (self.J, self.U)) assert_equals(gpm.bb.shape, (self.J, self.U))
def test_HMM_entropy_positive(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_priors().set_inits() gpm.iterate() # need to do this to handle wonky initial conditions niter = 5 for _ in xrange(niter): gpm.iterate(keeplog=True) Hvals = np.array(gpm.log['H']) assert_true(np.all((Hvals > 0) | np.isclose(Hvals, 0)))
def test_cached_G_prod(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_priors().set_inits() gpm.iterate() npt.assert_allclose(gpm._Gtu, gpm.G_prod()) kk = 3 npt.assert_allclose(gpm._Gtku[:, kk], gpm.G_prod(kk)) npt.assert_allclose(gpm.G_prod(kk, update=True), gpm._Gtku[:, kk]) npt.assert_allclose(np.prod(gpm._Gpre, axis=1), gpm._Gtu) assert_equals(gpm.G_prod().shape[0], gpm.Xframe.shape[0]) assert_equals(gpm.G_prod(kk).shape[0], gpm.Xframe.shape[0])
def test_can_handle_no_regressors(self): # first, remove extra regressors cols = ['frame', 'unit', 'count', 'movie'] N = self.N[cols] gpm = gp.GPModel(N, self.K, self.dt) assert_equals(gpm.J, 0) assert_true(not gpm.regressors) assert_not_in('aa', gpm.variational_pars) assert_not_in('bb', gpm.variational_pars) assert_not_in('vv', gpm.prior_pars) assert_not_in('ww', gpm.prior_pars)
def test_can_include_overdispersion(self): gpm = gp.GPModel(self.N, self.K, self.dt, overdispersion=True) gpm.set_priors() assert_in('rr', gpm.prior_pars) assert_in('ss', gpm.prior_pars) assert_equals(gpm.rr.shape, (gpm.U, )) assert_equals(gpm.ss.shape, (gpm.U, )) gpm.set_inits() assert_in('omega', gpm.variational_pars) assert_in('zeta', gpm.variational_pars) assert_equals(gpm.omega.shape, (gpm.M, )) assert_equals(gpm.zeta.shape, (gpm.M, ))
def test_can_instantiate_model_object(self): gpm = gp.GPModel(self.N, self.K, self.dt) assert_is_instance(gpm, gp.GPModel) assert_equals(gpm.U, self.U) assert_equals(gpm.T, self.T) assert_equals(gpm.K, self.K) assert_equals(gpm.dt, self.dt) assert_equals(gpm.Xframe.shape, (self.T * self.U, self.X.shape[1] - 1)) # get regressors for first unit first_unit = gpm.Xframe.groupby(self.N['frame']).first() # compare to X itself npt.assert_array_equal(first_unit, self.X.iloc[:, 1:].values) assert_is_instance(gpm.Lvalues, list)
def test_iteration_increases_L(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_priors().set_inits() gpm.iterate() # need to do this to handle wonky initial conditions Lvals = [gpm.L()] niter = 1 for _ in xrange(niter): gpm.iterate(keeplog=True) Lvals.append(gpm.L()) # because of inexact solutions to update equations, there may be small # decreases in the objective function; we just want to test that these # aren't large, which would signal a problem change = np.diff(Lvals) percent_change = change / np.abs(Lvals[:-1]) decreases = percent_change[percent_change < 0] assert_true(np.all(np.abs(decreases) <= 0.01))
def test_invalid_init_shapes_raises_error(self): gpm = gp.GPModel(self.N, self.K, self.dt) assert_raises(ValueError, gpm.set_inits, alpha=np.ones((self.K, self.U, 1))) assert_raises(ValueError, gpm.set_inits, beta=np.ones((self.K, ))) assert_raises(ValueError, gpm.set_inits, gamma1=np.ones((self.K + 1, self.U))) assert_raises(ValueError, gpm.set_inits, gamma2=np.ones((1, self.U))) assert_raises(ValueError, gpm.set_inits, delta1=np.ones((1, self.K))) assert_raises(ValueError, gpm.set_inits, delta2=np.ones((2, self.K, 1))) assert_raises(ValueError, gpm.set_inits, xi=np.ones((self.T, self.K, 1)))
def test_can_set_inits(self): gpm = gp.GPModel(self.N, self.K, self.dt) alphatest = np.random.rand(self.K, self.U) betatest = np.random.rand(self.K, self.U) gamma1test = np.random.rand(2, self.K) gamma2test = np.random.rand(2, self.K) delta1test = np.random.rand(self.K) delta2test = np.random.rand(self.K) xitest = np.random.rand(self.T, self.K) Xitest = np.random.rand(self.T - 1, self.K, 2, 2) gpm.set_inits(alpha=alphatest, beta=betatest, gamma1=gamma1test, gamma2=gamma2test, delta1=delta1test, delta2=delta2test, xi=xitest, Xi=Xitest) npt.assert_array_equal(gpm.alpha, alphatest) npt.assert_array_equal(gpm.beta, betatest) npt.assert_array_equal(gpm.gamma1, gamma1test) npt.assert_array_equal(gpm.gamma2, gamma2test) npt.assert_array_equal(gpm.delta1, delta1test) npt.assert_array_equal(gpm.delta2, delta2test) npt.assert_array_equal(gpm.xi, xitest) # Xi will have been normalized, and since baseline category is # included by default, Xi[:, k] = [[0, 0] , [0, 1]] Xinorm = Xitest / np.sum(Xitest, axis=(-1, -2), keepdims=True) npt.assert_allclose(gpm.Xi, Xinorm) npt.assert_allclose(np.sum(gpm.Xi, axis=(-1, -2)), np.ones((self.T - 1, self.K))) assert_equals(gpm._Ftu.shape, (gpm.T, gpm.U)) assert_equals(gpm._Ftku.shape, (gpm.T, gpm.K, gpm.U))
def test_inference_appends_to_Lvalues(self): gpm = gp.GPModel(self.N, self.K, self.dt) assert_equals(len(gpm.Lvalues), 0) gpm.set_priors().set_inits() gpm.do_inference(tol=1) assert_equals(len(gpm.Lvalues), 1)
def test_L(self): # just test that we can run the function without errors gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_priors().set_inits() L0 = gpm.L() assert_equals(L0.shape, ())
def test_calc_A(self): gpm = gp.GPModel(self.N, self.K, self.dt) gpm.set_inits() A = gpm.calc_log_A() assert_equals(A.shape, (2, 2, self.K))
def test_can_use_exact_optimization(self): gpm = gp.GPModel(self.N, self.K, self.dt, regression_updater='exact') assert_equals(gpm.updater, 'exact')