converted_factors,
skip_existing=False) # create lpot_funs to be used by baseline
cond_g.init_rv_indices(
) # create indices in the conditional mrf (for baseline and osi)
utils.set_nbrs_idx_in_factors(
converted_factors, cond_g.Vd_idx,
cond_g.Vc_idx) # preprocessing for baseline
num_dstates = np.prod([rv.dstates for rv in cond_g.Vd])
print(
f'running {algo_name} baseline with {num_dstates} joint discrete configs'
)
if baseline == 'exact':
bn_res = convert_to_bn(converted_factors,
cond_g.Vd,
cond_g.Vc,
return_logZ=True)
bn = bn_res[:-1]
logZ = bn_res[-1]
print('true -logZ', -logZ)
obj = -logZ
# print('BN params', bn)
# num_dstates = np.prod([rv.dstates for rv in cond_g.Vd])
if num_dstates > 1000:
print(
'too many dstates, exact mode finding might take a while, consider parallelizing...'
)
for i, rv in enumerate(query_rvs):
m = get_rv_marg_map_from_bn_params(*bn, cond_g.Vd_idx,
MLNPotential), 'currently can only handle MLN'
factor.potential = equiv_hybrid_pot
assert isinstance(
factor.potential,
(TablePotential, QuadraticPotential, HybridQuadraticPotential))
g2.factors.append(factor)
utils.set_log_potential_funs(
g2.factors,
skip_existing=False) # create lpot_funs to be used by baseline
g2.init_rv_indices()
Vd, Vc, Vd_idx, Vc_idx = g2.Vd, g2.Vc, g2.Vd_idx, g2.Vc_idx
# currently using the same ans
if baseline == 'exact':
bn_res = convert_to_bn(g2.factors, Vd, Vc, return_logZ=True)
bn = bn_res[:-1]
logZ = bn_res[-1]
print('true -logZ', -logZ)
# print('BN params', bn)
num_dstates = np.prod(g2.dstates)
if num_dstates > 1000:
print(
'num modes too large, exact mode finding might take a while, consider parallelizing...'
)
for i, key in enumerate(key_list):
rv = rvs_table[key]
ans[key] = get_rv_marg_map_from_bn_params(*bn, Vd_idx, Vc_idx, rv)
# ans[key] = 0
hgsampler = HybridGaussianSampler(g)
hgsampler.block_gibbs_sample(num_burnin=num_burnin,
num_samples=num_samples,
disc_block_its=20)
disc_samples, cont_samples = hgsampler.disc_samples, hgsampler.cont_samples
sampled_disc_marginal_table = hgsampler.sampled_disc_marginal_table
baseline_mmap = np.empty(len(rvs))
for i, rv in enumerate(rvs):
baseline_mmap[i] = hgsampler.map(rv, num_gm_components_for_crv=K)
print('comparing to sampling baseline')
for a, name in enumerate(names):
print(f'{name} mmap diff', mmap_res[a] - baseline_mmap)
print('converting hybrid MLN to BN')
bn_res = convert_to_bn(factors, Vd, Vc, return_Z=True)
bn = bn_res[:-1]
Z = bn_res[-1]
print('BN params', bn)
print('true -logZ', -np.log(Z))
baseline_mmap = np.empty(len(rvs))
for i, rv in enumerate(rvs):
baseline_mmap[i] = get_rv_marg_map_from_bn_params(*bn, Vd_idx, Vc_idx, rv)
print('comparing to exact baseline')
for a, name in enumerate(names):
print(f'{name} mmap diff', mmap_res[a] - baseline_mmap)
# the rest just looks at node marginals for fun
test_drv_idx = 0
F(nb=(rvs[2], ),
log_potential_fun=LogQuadratic(A=-0.5 * np.ones([1, 1]),
b=np.zeros([1]),
c=0.))
]
Vd = [rv for rv in rvs if rv.domain_type[0] == 'd'] # list of of discrete rvs
Vc = [rv for rv in rvs if rv.domain_type[0] == 'c'] # list of cont rvs
Vd_idx = {n: i for (i, n) in enumerate(Vd)}
Vc_idx = {n: i for (i, n) in enumerate(Vc)}
utils.set_nbrs_idx_in_factors(
factors, Vd_idx=Vd_idx,
Vc_idx=Vc_idx) # pre-processing for hybrid mln stuff
dstates = [rv.dstates for rv in Vd]
bn = convert_to_bn(factors, Vd, Vc)
print('BN params', bn)
num_burnin = 200
num_samples = 500
disc_samples, cont_samples = block_gibbs_sample(factors,
Vd=Vd,
Vc=Vc,
num_burnin=num_burnin,
num_samples=num_samples,
disc_block_its=20,
seed=seed)
sampled_disc_marginal_table = sampling_utils.get_disc_marg_table_from_samples(
disc_samples, dstates)
test_drv_idx = 0