def sample_instances(node, input_data, rand_gen, node_sampling=_node_sampling, in_place=False):
"""
Implementing hierarchical sampling
"""
# first, we do a bottom-up pass to compute the likelihood taking into account marginals.
# then we do a top-down pass, to sample taking into account the likelihoods.
if in_place:
data = input_data
else:
data = np.array(input_data)
valid, err = is_valid(node)
assert valid, err
assert np.all(
np.any(np.isnan(data), axis=1)), "each row must have at least a nan value where the samples will be substituted"
nodes = get_nodes_by_type(node)
lls_per_node = np.zeros((data.shape[0], len(nodes)))
log_likelihood(node, data, dtype=data.dtype, lls_matrix=lls_per_node)
instance_ids = np.arange(data.shape[0])
eval_spn_top_down(node, node_sampling, input_vals=instance_ids, data=data, lls_per_node=lls_per_node,
rand_gen=rand_gen)
return data
def mpe(
node,
input_data,
node_top_down_mpe=_node_top_down_mpe,
node_bottom_up_mpe_log=_node_bottom_up_mpe_log,
in_place=False,
):
valid, err = is_valid(node)
assert valid, err
assert np.all(
np.any(np.isnan(input_data), axis=1)
), "each row must have at least a nan value where the samples will be substituted"
if in_place:
data = input_data
else:
data = np.array(input_data)
nodes = get_nodes_by_type(node)
lls_per_node = np.zeros((data.shape[0], len(nodes)))
# one pass bottom up evaluating the likelihoods
log_likelihood(node, data, dtype=data.dtype, node_log_likelihood=node_bottom_up_mpe_log, lls_matrix=lls_per_node)
instance_ids = np.arange(data.shape[0])
# one pass top down to decide on the max branch until it reaches a leaf, then it fills the nan slot with the mode
eval_spn_top_down(node, node_top_down_mpe, parent_result=instance_ids, data=data, lls_per_node=lls_per_node)
return data
def gradient_backward(spn, lls_per_node, node_gradients=_node_gradients):
gradient_result = np.zeros_like(lls_per_node)
eval_spn_top_down(
spn,
node_gradients,
parent_result=np.zeros((lls_per_node.shape[0])),
gradient_result=gradient_result,
lls_per_node=lls_per_node,
)
return gradient_result
def gradient_backward(spn, lls_per_node):
node_gradients = {}
node_gradients[Sum] = sum_gradient_backward
node_gradients[Product] = prod_gradient_backward
node_gradients[Leaf] = leaf_gradient_backward
gradient_result = np.zeros_like(lls_per_node)
eval_spn_top_down(
spn,
node_gradients,
parent_result=np.zeros((lls_per_node.shape[0])),
gradient_result=gradient_result,
lls_per_node=lls_per_node,
)
return gradient_result
def backprop_gradient(spn, evidence):
probs = likelihood(spn, evidence)
_node_gradients[Sum] = sum_gradient_backward
_node_gradients[Product] = prod_gradient_backward
node_gradients = _node_gradients
all_gradients = {}
gradients_input = eval_spn_top_down(spn,
node_gradients,
all_results=all_gradients,
probs=probs)
return gradients_input