def __getitem__(self, index): lops = np.random.uniform(0.0, 1.0, (self.chain_length, 2)) pws = self.transition hk = self.hop_order // 2 g = fg.PFactorGraph() var_list = [] for i in range(self.chain_length): v = g.create_multi_variable(2) v.set_log_potentials(lops[i]) var_list.append(v) for i in range(self.chain_length - 1): g.create_factor_dense([var_list[i], var_list[i + 1]], pws) for i in range(self.chain_length - self.hop_order + 1): v_list = [ var_list[j].get_state(1) for j in range(i, i + self.hop_order) ] g.create_factor_budget(v_list, self.cap) val, post, _, stat = g.solve(tol=1e-6, branch_and_bound=True) post = np.reshape(np.asarray(post), [self.chain_length, 2]) assign = np.argmax(post, axis=1) node_feature = np.transpose(lops.astype(np.float32), [1, 0]) g = fg.PFactorGraph() var_list = [] for i in range(self.chain_length): v = g.create_multi_variable(2) v.set_log_potentials(lops[i]) var_list.append(v) for i in range(self.chain_length - 1): g.create_factor_dense([var_list[i], var_list[i + 1]], pws) for i in range(self.chain_length - self.hop_order + 1): v_list = [ var_list[j].get_state(1) for j in range(i, i + self.hop_order) ] g.create_factor_budget(v_list, self.cap) val1, post1, _, status = g.solve(branch_and_bound=False) post1 = np.reshape(np.asarray(post1), [self.chain_length, 2]) assign1 = np.argmax(post1, axis=1) return node_feature, assign, assign1
def __init__(self, instance, parts, scores): self.left_siblings = None self.right_siblings = None self.left_grandparents = None self.right_grandparents = None self.left_grandsiblings = None self.right_grandsiblings = None self.use_siblings = parts.has_type(Target.NEXT_SIBLINGS) self.use_grandparents = parts.has_type(Target.GRANDPARENTS) self.use_grandsiblings = parts.has_type(Target.GRANDSIBLINGS) # arcs is a list of tuples (h, m) heads, modifiers = parts.get_arc_indices() self.arcs = list(zip(heads, modifiers)) self.arc_index = parts.create_arc_index() # these indices keep track of the higher order parts added to the graph self.additional_indices = [] self.graph = fg.PFactorGraph() variables = self.create_tree_factor(instance, parts, scores) self._index_parts_by_head(parts, instance, scores) if self.use_grandsiblings or \ (self.use_siblings and self.use_grandparents): self.create_gp_head_automata(variables) elif self.use_grandparents: self.create_grandparent_factors(parts, scores, variables) elif self.use_siblings: self.create_head_automata(variables)
def test_logic_constraints(): graph = fg.PFactorGraph() n_states = 3 var_a = graph.create_multi_variable(n_states) var_b = graph.create_multi_variable(n_states) var_a.set_log_potential(0, 1) # A = 0 var_b.set_log_potential(1, 10) # B = likely 1, possibly 2 var_b.set_log_potential(2, 9.5) graph.fix_multi_variables_without_factors() value_unconstrained, marginals, _, _ = graph.solve() expected = [0, 1] obtained = np.array(marginals).reshape(2, -1).argmax(axis=1) assert_array_equal(expected, obtained) # add logic constraint: (A = 0) -> not (B = 1) graph.create_factor_logic('IMPLY', [var_a.get_state(0), var_b.get_state(1)], [False, True]) graph.fix_multi_variables_without_factors() # need to run this again value_constrained, marginals, _, _ = graph.solve() expected = [0, 2] obtained = np.array(marginals).reshape(2, -1).argmax(axis=1) assert_array_equal(expected, obtained) # total score must be lower assert value_constrained < value_unconstrained
def test_pair(): graph = fg.PFactorGraph() a = graph.create_binary_variable() b = graph.create_binary_variable() assert a.get_degree() == b.get_degree() == 0 val = 100.0 graph.create_factor_pair([a, b], val) assert a.get_degree() == b.get_degree() == 1 graph.create_factor_pair([a, b], -val) assert a.get_degree() == b.get_degree() == 2 with pytest.raises(TypeError): graph.create_factor_pair([a, b], None) with pytest.raises(TypeError): graph.create_factor_pair(None, val) with pytest.raises(TypeError): graph.create_factor_pair(-1, val) with pytest.raises(TypeError): graph.create_factor_pair([a, -1], val) with pytest.raises(AttributeError): graph.create_factor_pair([a, None], val) with pytest.raises(ValueError): graph.create_factor_pair([a, b, a], val)
def test_solve(): rng = np.random.RandomState(0) graph = fg.PFactorGraph() a = graph.create_multi_variable(3) b = graph.create_multi_variable(3) c = graph.create_multi_variable(3) a.set_log_potentials(rng.randn(3)) b.set_log_potentials(rng.randn(3)) c.set_log_potentials(rng.randn(3)) graph.create_factor_dense([a, b], rng.randn(3 * 3)) graph.create_factor_dense([a, c], rng.randn(3 * 3)) graph.create_factor_dense([b, c], rng.randn(3 * 3)) val, _, _, status = graph.solve() assert status == 'integral' val_one_iter, _, _, status_one_iter = graph.solve(max_iter=1) assert status_one_iter == 'unsolved' assert val_one_iter < val val_lowtol, _, _, status_lowtol = graph.solve(tol=0.3) assert status_lowtol == 'fractional' assert val_lowtol > val val_lowtol_bb, _, _, status_lowtol_bb = graph.solve(tol=0.3, branch_and_bound=True) assert status_lowtol_bb == 'integral' assert (val_lowtol_bb - val) ** 2 < 1e-8
def test_primal_dual_vars(): g = fg.PFactorGraph() g.solve() assert g.get_dual_variables() == [] assert g.get_local_primal_variables() == [] assert g.get_global_primal_variables() == [] g = fg.PFactorGraph() a = g.create_binary_variable() a.set_log_potential(0) b = g.create_binary_variable() b.set_log_potential(1) g.create_factor_pair([a, b], -2) g.create_factor_pair([a, b], -10) g.solve() assert len(g.get_dual_variables()) == 4 assert len(g.get_local_primal_variables()) == 4 assert len(g.get_global_primal_variables()) == 2
def _generate_graph(self): g = fg.PFactorGraph() var_list = [] for i in range(self.chain_length): v = g.create_multi_variable(2) v.set_log_potentials(self.lops[i]) var_list.append(v) for i in range(self.chain_length - 1): g.create_factor_dense([var_list[i], var_list[i + 1]], self.pws) return g
def test_logic_negate(): # not a & not b is equiv to not(a or b) rng = np.random.RandomState() for _ in range(10): potentials = rng.randn(3) graph = fg.PFactorGraph() variables = [graph.create_binary_variable() for _ in range(3)] for var, val in zip(variables, potentials): var.set_log_potential(val) graph.create_factor_logic('ANDOUT', variables, [True, True, False]) val_1, (_, _, out_1), _, _ = graph.solve() graph = fg.PFactorGraph() variables = [graph.create_binary_variable() for _ in range(3)] for var, val in zip(variables, potentials): var.set_log_potential(val) graph.create_factor_logic('OROUT', variables, [False, False, True]) val_2, (_, _, out_2), _, _ = graph.solve() assert val_1 == val_2 assert out_1 == out_2
def test_budget(): graph = fg.PFactorGraph() potentials = [100, 1, 100, 1, 100] for val in potentials: var = graph.create_binary_variable() var.set_log_potential(val) _, assign, _, _ = graph.solve() assert sum(assign) == 5 budget = 3 graph = fg.PFactorGraph() variables = [graph.create_binary_variable() for _ in potentials] for var, val in zip(variables, potentials): var.set_log_potential(val) graph.create_factor_budget(variables, budget=budget) _, assign, _, status = graph.solve() assert_array_almost_equal(assign, [1, 0, 1, 0, 1])
def test_knapsack(): graph = fg.PFactorGraph() potentials = [100, 1, 100, 1, 100] costs = [3, 5, 5, 5, 2] for val in potentials: var = graph.create_binary_variable() var.set_log_potential(val) _, assign, _, _ = graph.solve() assert sum(assign) == 5 budget = 5 graph = fg.PFactorGraph() variables = [graph.create_binary_variable() for _ in potentials] for var, val in zip(variables, potentials): var.set_log_potential(val) graph.create_factor_knapsack(variables, costs, budget) _, assign, _, status = graph.solve(branch_and_bound=True) assert_array_almost_equal(assign, [1, 0, 0, 0, 1])
def test_smoke_logic(factor_type): graph = fg.PFactorGraph() variables = [graph.create_binary_variable() for _ in range(3)] for var in variables: assert var.get_degree() == 0 graph.create_factor_logic(factor_type, variables) for var in variables: assert var.get_degree() == 1 # check that we find a feasible solution val, _, _, _ = graph.solve() assert val == 0
def solve_lp_knapsack_ad3(scores, costs, budget): factor_graph = fg.PFactorGraph() binary_variables = [] for i in range(len(scores)): binary_variable = factor_graph.create_binary_variable() binary_variable.set_log_potential(scores[i]) binary_variables.append(binary_variable) factor_graph.create_factor_knapsack(binary_variables, costs=costs, budget=budget) # Run AD3. _, posteriors, _, _ = factor_graph.solve() return posteriors
def test_logic_validate(): graph = fg.PFactorGraph() variables = [graph.create_binary_variable() for _ in range(3)] with pytest.raises(NotImplementedError) as e: graph.create_factor_logic('foo', variables) assert 'unknown' in str(e.value).lower() with pytest.raises(ValueError): graph.create_factor_logic('OR', variables, negated=[True]) with pytest.raises(ValueError): graph.create_factor_logic('OR', variables, negated=[True] * 10) with pytest.raises(TypeError): graph.create_factor_logic('OR', variables, negated=42)
def test_dense(): graph = fg.PFactorGraph() n_a = 2 a = graph.create_multi_variable(n_a) n_b = 3 b = graph.create_multi_variable(n_b) vals = np.arange(n_a * n_b) def check_degree_all(degree): for i in range(n_a): assert a.get_state(i).get_degree() == degree for i in range(n_b): assert b.get_state(i).get_degree() == degree check_degree_all(0) graph.create_factor_dense([a, b], vals) check_degree_all(1) graph.create_factor_dense([a, b], vals) check_degree_all(2) with pytest.raises(TypeError): graph.create_factor_dense(None, vals) with pytest.raises(TypeError): graph.create_factor_dense(-1, vals) with pytest.raises(TypeError): graph.create_factor_dense([a, -1], vals) with pytest.raises(AttributeError): graph.create_factor_dense([a, None], vals) with pytest.raises(ValueError): graph.create_factor_dense([a, b], vals[:-1]) with pytest.raises(ValueError): graph.create_factor_dense([a, b], np.concatenate([vals, vals])) with pytest.raises(TypeError): graph.create_factor_dense([a, b], None)
def _generate_graph(self): g = fg.PFactorGraph() var_list = [] for i in range(self.chain_length): v = g.create_multi_variable(2) v.set_log_potentials(self.lops[i]) var_list.append(v) for i in range(self.chain_length - 1): g.create_factor_dense([var_list[i], var_list[i + 1]], self.pws[i][0]) for i in range(self.chain_length - self.hop_order + 1): v_list = [ var_list[j].get_state(1) for j in range(i, i + self.hop_order) ] g.create_factor_budget(v_list, self.cap[i + self.half_hop]) return g
def solve_lp_knapsack_ad3(scores, costs, budget): factor_graph = fg.PFactorGraph() binary_variables = [] for i in xrange(len(scores)): binary_variable = factor_graph.create_binary_variable() binary_variable.set_log_potential(scores[i]) binary_variables.append(binary_variable) negated = [False] * len(binary_variables) factor_graph.create_factor_knapsack(binary_variables, negated, costs, budget) #pdb.set_trace() # Run AD3. factor_graph.set_verbosity(1) factor_graph.set_eta_ad3(.1) factor_graph.adapt_eta_ad3(True) factor_graph.set_max_iterations_ad3(1000) value, posteriors, additional_posteriors, status = factor_graph.solve_lp_map_ad3() return posteriors
def test_sequence_dense(): n_states = 3 transition = np.eye(n_states).ravel() graph = fg.PFactorGraph() vars_expected = [0, 1, None, None, 1] variables = [graph.create_multi_variable(n_states) for _ in vars_expected] for prev, curr in zip(variables, variables[1:]): graph.create_factor_dense([prev, curr], transition) for var, ix in zip(variables, vars_expected): if ix is not None: var.set_log_potential(ix, 1) value, marginals, additionals, status = graph.solve() # 3 points for "observed" values, 3 points for consecutive equal vals assert value == 6 expected = [0, 1, 1, 1, 1] obtained = np.array(marginals).reshape(5, -1).argmax(axis=1) assert_array_equal(expected, obtained)
def test_knapsack_wrong_cost_size(): graph = fg.PFactorGraph() n_vars = 50 variables = [graph.create_binary_variable() for _ in range(n_vars)] budget = 1 with pytest.raises(ValueError): small_cost = [17] graph.create_factor_knapsack(variables, costs=small_cost, budget=budget) with pytest.raises(ValueError): big_cost = [17] * (n_vars + 1) graph.create_factor_knapsack(variables, costs=big_cost, budget=budget) with pytest.raises(TypeError): graph.create_factor_knapsack(variables, costs=42, budget=budget) with pytest.raises(TypeError): graph.create_factor_knapsack(variables, costs=None, budget=budget)
def test_dense_at_most_one(): # check that dense factor enforces one-of-k graph = fg.PFactorGraph() n = 3 a = graph.create_multi_variable(n) b = graph.create_multi_variable(n) a.set_log_potentials(-100 * np.ones(3)) b.set_log_potentials(np.ones(3)) dense_vals = np.zeros((3, 3)) dense_vals[0, 0] = 1 dense_vals[1, 2] = 10 # (0, 0, 0) / (0, 0, 0) would be highest if allowed # (1, 1, 0) / (1, 0, 1) would be highest otherwise, if allowed # (0, 1, 0) / (0, 0, 1) is the highest allowable. graph.create_factor_dense([a, b], dense_vals.ravel()) _, assignments, _, _ = graph.solve() expected = np.array([0, 1, 0, 0, 0, 1]) assert_array_equal(expected, assignments)
def test_multi_variable(): graph = fg.PFactorGraph() five = graph.create_multi_variable(5) assert len(five) == 5 vals = np.arange(5).astype(np.double) five[1] = vals[1] assert five[1] == vals[1] five.set_log_potentials(vals) for i in range(5): assert five[i] == vals[i] state = five.get_state(1) assert state.get_log_potential() == vals[1] with pytest.raises(IndexError): five.get_state(6) with pytest.raises(IndexError): five[6] with pytest.raises(IndexError): five[6] = 1.1
def _inference(self, x, potentials, exact=False, relaxed=True, return_energy=False, constraints=None, eta=0.1, adapt=True, max_iter=5000, verbose=False): (prop_potentials, link_potentials, compat_potentials, coparent_potentials, grandparent_potentials, sibling_potentials) = potentials n_props, n_prop_classes = prop_potentials.shape n_links, n_link_classes = link_potentials.shape g = fg.PFactorGraph() g.set_verbosity(verbose) prop_vars = [ g.create_multi_variable(n_prop_classes) for _ in range(n_props) ] link_vars = [ g.create_multi_variable(n_link_classes) for _ in range(n_links) ] for var, scores in zip(prop_vars, prop_potentials): for state, score in enumerate(scores): var.set_log_potential(state, score) for var, scores in zip(link_vars, link_potentials): for state, score in enumerate(scores): var.set_log_potential(state, score) # compatibility trigram factors compat_factors = [] link_vars_dict = {} link_on, link_off = self.link_encoder_.transform([True, False]) # account for compat features if self.compat_features: assert compat_potentials.shape[0] == n_links compats = compat_potentials else: compats = (compat_potentials for _ in range(n_links)) for (src, trg), link_v, compat in zip(x.link_to_prop, link_vars, compats): src_v = prop_vars[src] trg_v = prop_vars[trg] compat_factors.append( g.create_factor_dense([src_v, trg_v, link_v], compat.ravel())) # keep track of binary link variables, for constraints. # we need .get_state() to get the underlaying PBinaryVariable link_vars_dict[src, trg] = link_v.get_state(link_on) # second-order factors coparent_factors = [] grandparent_factors = [] sibling_factors = [] for score, (a, b, c) in zip(coparent_potentials, x.second_order): # a -> b <- c vars = [link_vars_dict[a, b], link_vars_dict[c, b]] coparent_factors.append(g.create_factor_pair(vars, score)) for score, (a, b, c) in zip(grandparent_potentials, x.second_order): # a -> b -> c vars = [link_vars_dict[a, b], link_vars_dict[b, c]] grandparent_factors.append(g.create_factor_pair(vars, score)) for score, (a, b, c) in zip(sibling_potentials, x.second_order): # a <- b -> c vars = [link_vars_dict[b, a], link_vars_dict[b, c]] sibling_factors.append(g.create_factor_pair(vars, score)) # domain-specific constraints if constraints and 'cdcp' in constraints: # antisymmetry: if a -> b, then b cannot -> a for src in range(n_props): for trg in range(src): fwd_link_v = link_vars_dict[src, trg] rev_link_v = link_vars_dict[trg, src] g.create_factor_logic('ATMOSTONE', [fwd_link_v, rev_link_v], [False, False]) # transitivity. # forall a != b != c: a->b and b->c imply a->c for a, b, c in permutations(range(n_props), 3): ab_link_v = link_vars_dict[a, b] bc_link_v = link_vars_dict[b, c] ac_link_v = link_vars_dict[a, c] g.create_factor_logic('IMPLY', [ab_link_v, bc_link_v, ac_link_v], [False, False, False]) # standard model: if 'strict' in constraints: for src, trg in x.link_to_prop: src_v = prop_vars[src] trg_v = prop_vars[trg] for types in CDCP_ILLEGAL_LINKS: src_ix, trg_ix = self.prop_encoder_.transform(types) g.create_factor_logic('IMPLY', [ src_v.get_state(src_ix), trg_v.get_state(trg_ix), link_vars_dict[src, trg] ], [False, False, True]) elif constraints and 'ukp' in constraints: # Tree constraints using AD3 MST factor for each paragraph. # First, identify paragraphs prop_para = np.array(x.prop_para) link_para = prop_para[x.link_to_prop[:, 0]] tree_factors = [] for para_ix in np.unique(link_para): props = np.where(prop_para == para_ix)[0] offset = props.min() para_vars = [] para_arcs = [] # call them arcs, semantics differ from links # add a new head node pointing to every possible variable for relative_ix, prop_ix in enumerate(props, 1): para_vars.append(g.create_binary_variable()) para_arcs.append((0, relative_ix)) # add an MST arc for each link for src, trg in x.link_to_prop[link_para == para_ix]: relative_src = src - offset + 1 relative_trg = trg - offset + 1 para_vars.append(link_vars_dict[src, trg]) # MST arcs have opposite direction from argument links! # because each prop can have multiple supports but not # the other way around para_arcs.append((relative_trg, relative_src)) tree = fg.PFactorTree() g.declare_factor(tree, para_vars, True) tree.initialize(1 + len(props), para_arcs) tree_factors.append(tree) if 'strict' in constraints: # further domain-specific constraints mclaim_ix, claim_ix, premise_ix = self.prop_encoder_.transform( ['MajorClaim', 'Claim', 'Premise']) # a -> b implies a = 'premise' for (src, trg), link_v in zip(x.link_to_prop, link_vars): src_v = prop_vars[src] g.create_factor_logic('IMPLY', [ link_v.get_state(link_on), src_v.get_state(premise_ix) ], [False, False]) g.fix_multi_variables_without_factors() g.set_eta_ad3(eta) g.adapt_eta_ad3(adapt) g.set_max_iterations_ad3(max_iter) if exact: val, posteriors, additionals, status = g.solve_exact_map_ad3() else: val, posteriors, additionals, status = g.solve_lp_map_ad3() status = ["integer", "fractional", "infeasible", "not solved"][status] prop_marg = posteriors[:n_props * n_prop_classes] prop_marg = np.array(prop_marg).reshape(n_props, -1) link_marg = posteriors[n_props * n_prop_classes:] # remaining posteriors are for artificial root nodes for MST factors link_marg = link_marg[:n_links * n_link_classes] link_marg = np.array(link_marg).reshape(n_links, -1) n_compat = n_links * n_link_classes * n_prop_classes**2 compat_marg = additionals[:n_compat] compat_marg = np.array(compat_marg).reshape( (n_links, n_prop_classes, n_prop_classes, n_link_classes)) second_ordermarg = np.array(additionals[n_compat:]) posteriors = (prop_marg, link_marg) additionals = (compat_marg, second_ordermarg) if relaxed: y_hat = posteriors, additionals else: y_hat = self._round(prop_marg, link_marg, prop_potentials, link_potentials) if return_energy: return y_hat, status, -val else: return y_hat, status
num_children = rng.randint(1, max_available + 1) ind_children = rng.permutation(num_available)[:num_children] children = [available_nodes[j] for j in ind_children] for j in children: parents[j] = i nodes_to_process.insert(0, j) available_nodes.remove(j) print(parents) # generate random potentials var_log_potentials = rng.randn(num_nodes) edge_log_potentials = rng.randn(num_nodes - 1, 4) # 1) Build a factor graph using DENSE factors. pairwise_fg = fg.PFactorGraph() multi_variables = [] for i in range(num_nodes): multi_variable = pairwise_fg.create_multi_variable(2) multi_variable[0] = 0 multi_variable[1] = var_log_potentials[i] multi_variables.append(multi_variable) # random edge potentials for i in range(1, num_nodes): var = multi_variables[i] parent = multi_variables[parents[i]] pairwise_fg.create_factor_dense([parent, var], edge_log_potentials[i - 1]) # If there are upper/lower bounds, add budget factors.
import itertools import numpy as np import matplotlib.pyplot as plt import pdb import ad3.factor_graph as fg grid_size = 20 num_states = 5 factor_graph = fg.PFactorGraph() multi_variables = [] random_grid = np.random.uniform(size=(grid_size, grid_size, num_states)) for i in xrange(grid_size): multi_variables.append([]) for j in xrange(grid_size): new_variable = factor_graph.create_multi_variable(num_states) for state in xrange(num_states): new_variable.set_log_potential(state, random_grid[i, j, state]) multi_variables[i].append(new_variable) alpha = .3 potts_matrix = alpha * np.eye(num_states) potts_potentials = potts_matrix.ravel().tolist() for i, j in itertools.product(xrange(grid_size), repeat=2): if (j > 0): #horizontal edge edge_variables = [multi_variables[i][j - 1], multi_variables[i][j]] factor_graph.create_factor_dense(edge_variables, potts_potentials)
value = np.random.uniform() if value < 0.4: bigram_positions.append(i) # Decide whether each position counts for budget. counts_for_budget = [] for i in xrange(length): value = np.random.uniform() if value < 0.1: counts_for_budget.append(False) else: counts_for_budget.append(True) # 1) Build a factor graph using a SEQUENCE and a BUDGET factor. factor_graph = fg.PFactorGraph() multi_variables = [] for i in xrange(length): multi_variable = factor_graph.create_multi_variable(2) multi_variable.set_log_potential(0, 0.0) value = np.random.normal() multi_variable.set_log_potential(1, value) multi_variables.append(multi_variable) edge_log_potentials = [] for i in xrange(length+1): if i == 0: num_previous_states = 1 else: num_previous_states = 2 if i == length:
import itertools import numpy as np import matplotlib.pyplot as plt import pdb import ad3.factor_graph as fg grid_size = 10 num_states = 5 num_diverse_outputs = 4 # Number of diverse outputs to generate. min_hamming_cost = 32 # Minimum Hamming cost between any pair of outputs. factor_graph = fg.PFactorGraph() description = '' num_factors = 0 multi_variables = [] random_grid = np.random.uniform(size=(grid_size, grid_size, num_states)) for i in xrange(grid_size): multi_variables.append([]) for j in xrange(grid_size): new_variable = factor_graph.create_multi_variable(num_states) for state in xrange(num_states): new_variable.set_log_potential(state, random_grid[i, j, state]) multi_variables[i].append(new_variable) alpha = .3 potts_matrix = alpha * np.eye(num_states) potts_potentials = potts_matrix.ravel().tolist()
if num_children > len(available_nodes): num_children = len(available_nodes) ind_children = np.random.permutation(len(available_nodes))[0:num_children] children = [] for ind in ind_children: children.append(available_nodes[ind]) for j in children: parents[j] = i nodes_to_process.insert(0, j) available_nodes.remove(j) #parents = range(-1, num_nodes-1) print parents # 1) Build a factor graph using DENSE factors. pairwise_factor_graph = fg.PFactorGraph() multi_variables = [] for i in xrange(num_nodes): multi_variable = pairwise_factor_graph.create_multi_variable(2) value = np.random.normal() multi_variable.set_log_potential(0, 0.0) multi_variable.set_log_potential(1, value) multi_variables.append(multi_variable) description = '' num_factors = 0 edge_log_potentials = [] edge_log_potentials.append([]) for i in xrange(1, num_nodes): p = parents[i]
def test_binary_variable(): graph = fg.PFactorGraph() var = graph.create_binary_variable() var.set_log_potential(0.5) assert var.get_log_potential() == 0.5