def test_updates(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
assert_true(lnm.baseline)
assert_true(lnm.latents)
assert_true(lnm.regressors)
baseline = lnm.nodes['baseline']
baseline.update()
fr_latents = lnm.nodes['fr_latents']
fr_latents.update(1)
fr_regressors = lnm.nodes['fr_regressors']
fr_regressors.update(1)
# add overdispersion
lnm.initialize_overdispersion(**self.overdisp_dict)
lnm.finalize()
od = lnm.nodes['overdispersion']
od.update()
def test_inference(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
lnm.iterate()
assert_true(~np.isnan(lnm.L()))
def test_expected_log_evidence(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
Eloln = lnm.expected_log_evidence()
assert_is_instance(Eloln, np.float64)
def test_calc_log_evidence(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
lolnsi = lnm.calc_log_evidence(2)
assert_equals(lolnsi.shape, (self.T, 2))
def test_iterate(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
L_init = lnm.L(keeplog=True)
lnm.iterate(keeplog=True, verbosity=2)
assert_true(lnm.L() > L_init)
def test_L(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
assert_is_instance(lnm.L(), np.float64)
initial_log_len = len(lnm.log['L'])
L_init = lnm.L(keeplog=True)
assert_equals(len(lnm.log['L']), initial_log_len + 1)
def test_can_initialize_baseline(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
assert_in('baseline', lnm.nodes)
assert_is_instance(lnm.nodes['baseline'], nd.GaussianNode)
baseline = lnm.nodes['baseline']
prs = self.baseline_dict['prior_mean']
prr = self.baseline_dict['prior_prec']
pos = self.baseline_dict['post_mean']
por = self.baseline_dict['post_prec']
npt.assert_array_equal(prs, baseline.prior_mean)
npt.assert_array_equal(prr, baseline.prior_prec)
npt.assert_array_equal(pos, baseline.post_mean)
npt.assert_array_equal(por, baseline.post_prec)
def test_can_instantiate_model_object(self):
lnm = ln.LogNormalModel(self.N, self.K)
assert_is_instance(lnm, ln.LogNormalModel)
assert_equals(lnm.U, self.U)
assert_equals(lnm.T, self.T)
assert_equals(lnm.K, self.K)
assert_equals(lnm.Xframe.shape, (self.T * self.U, self.X.shape[1] - 1))
# get regressors for first unit
first_unit = lnm.Xframe.groupby(self.N['time']).first()
# compare to X itself
npt.assert_array_equal(first_unit, self.X.iloc[:, 1:].values)
assert_is_instance(lnm.nodes, dict)
def test_finalize(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.finalize()
assert_true(lnm.latents)
assert_true(not lnm.regressors)
assert_true(not lnm.overdispersion)
lnm.F()
lnm.initialize_fr_regressors(**self.fr_regressors_dict)
lnm.finalize()
assert_true(lnm.latents)
assert_true(lnm.regressors)
assert_true(not lnm.overdispersion)
def test_hier_updates(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_baseline(**self.baseline_dict)
lnm.initialize_fr_latents(**self.fr_latent_hier_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.initialize_fr_regressors(**self.fr_regressors_hier_dict)
lnm.finalize()
assert_true(lnm.baseline)
assert_true(lnm.latents)
assert_true(lnm.regressors)
baseline = lnm.nodes['baseline']
baseline.update()
fr_latents = lnm.nodes['fr_latents']
fr_latents.update(1)
fr_regressors = lnm.nodes['fr_regressors']
fr_regressors.update(1)
def test_F(self):
# initialize model
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_fr_latents(**self.fr_latent_dict)
lnm.initialize_latents(**self.latent_dict)
lnm.finalize()
# initialize/cache F_prod
lnm.F(update=True)
# test shapes
assert_equals(lnm.F(1).shape, (self.M, ))
assert_equals(lnm.F().shape, (self.M, ))
# test caching
npt.assert_allclose(lnm.F(1), lnm._Fk_flat[..., 1])
npt.assert_allclose(lnm.F(), lnm._F_flat)
def test_can_initialize_latents(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_latents(**self.latent_dict)
assert_in('HMM', lnm.nodes)
def test_can_initialize_overdispersion(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_overdispersion(**self.overdisp_dict)
assert_in('overdispersion', lnm.nodes)
assert_is_instance(lnm.nodes['overdispersion'], nd.GaussianNode)
def test_can_initialize_fr_regressors_hierarchy(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_fr_regressors(**self.fr_regressors_hier_dict)
assert_in('fr_regressors', lnm.nodes)
assert_is_instance(lnm.nodes['fr_regressors'], nd.GaussianNode)
assert_is_instance(lnm.nodes['fr_regressors_prec'], nd.GammaNode)
def test_can_initialize_fr_latents(self):
lnm = ln.LogNormalModel(self.N, self.K)
lnm.initialize_fr_latents(**self.fr_latent_dict)
assert_in('fr_latents', lnm.nodes)
assert_is_instance(lnm.nodes['fr_latents'], nd.GaussianNode)
