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')
