def test_tree_validate():
g = PFactorGraph()
n_nodes = 4
arcs = [(h, m) for m in range(1, n_nodes) for h in range(n_nodes)
if h != m]
arc_vars = [g.create_binary_variable() for _ in arcs]
tree = PFactorTree()
g.declare_factor(tree, arc_vars)
with pytest.raises(TypeError):
tree.initialize(n_nodes, [-3 for _ in arcs])
with pytest.raises(TypeError):
tree.initialize(n_nodes, None)
with pytest.raises(TypeError):
tree.initialize(n_nodes, 42)
with pytest.raises(ValueError):
tree.initialize(n_nodes, [(100, 100) for _ in arcs])
with pytest.raises(ValueError):
tree.initialize(n_nodes, arcs + arcs)
with pytest.raises(ValueError):
tree.initialize(n_nodes, arcs[:3])
def build_factor(self):
n_nodes = self.n_nodes
g = PFactorGraph()
self.arcs = [(h, m) for m in range(1, n_nodes + 1)
for h in range(n_nodes + 1) if h != m]
arc_vars = [g.create_binary_variable() for _ in self.arcs]
tree = PFactorTreeFast()
g.declare_factor(tree, arc_vars)
tree.initialize(n_nodes + 1)
return tree
def build_factor(self, n_arcs):
g = PFactorGraph()
n_nodes = self.n_nodes
arcs = self.arcs
if n_arcs != len(arcs):
raise ValueError("expected input dim of {:d} but got {:d}".format(len(arcs), n_arcs))
arc_vars = [g.create_binary_variable() for _ in arcs]
tree = PFactorTreeFast()
g.declare_factor(tree, arc_vars)
tree.initialize(n_nodes + 1)
return tree
def test_tree_factor():
n_nodes = 10
rng = np.random.RandomState(0)
g = PFactorGraph()
arcs = [(h, m) for m in range(1, n_nodes) for h in range(n_nodes)
if h != m]
potentials = rng.uniform(0, 1, size=len(arcs))
arc_vars = [g.create_binary_variable() for _ in arcs]
for var, potential in zip(arc_vars, potentials):
var.set_log_potential(potential)
tree = PFactorTree()
g.declare_factor(tree, arc_vars)
tree.initialize(n_nodes, arcs)
_, posteriors, _, _ = g.solve()
chosen_arcs = [arc for arc, post in zip(arcs, posteriors)
if post > 0.99]
# check that it's a tree
selected_nodes = set(a for arc in chosen_arcs for a in arc)
assert selected_nodes == set(range(n_nodes))
marked = list(range(n_nodes))
for h, t in chosen_arcs:
assert marked[t] != marked[h]
marked[t] = marked[h]
nodes_to_process.insert(0, j)
available_nodes.remove(j)
print("Randomly picked tree:", parents)
# Design number of states for each node.
num_states = rng.randint(1, max_num_states + 1, size=num_nodes)
print("States per node:", num_states)
# generate random potentials
var_log_potentials = [rng.randn(n) for n in num_states]
edge_log_potentials = [rng.randn(num_states[parents[i]] * num_states[i])
for i in range(1, num_nodes)]
# 1) Build a factor graph using DENSE factors.
pairwise_fg = PFactorGraph()
multi_variables = []
for i in range(num_nodes):
var = pairwise_fg.create_multi_variable(num_states[i])
var.set_log_potentials(var_log_potentials[i])
multi_variables.append(var)
description = ''
num_factors = 0
for i in range(1, num_nodes):
p = parents[i]
edge_variables = [multi_variables[p], multi_variables[i]]
pairwise_fg.create_factor_dense(edge_variables,
edge_log_potentials[i - 1])
num_factors += 1
rng = np.random.RandomState(1)
# Decide bigram_positions.
bigram_positions = []
for i in range(-1, length):
value = rng.uniform()
if value < 0.4:
bigram_positions.append(i)
# Decide whether each position counts for budget.
counts_for_budget = rng.uniform(size=length) < 0.1
var_log_potentials = rng.randn(length)
# 1) Build a factor graph using a SEQUENCE and a BUDGET factor.
factor_graph = PFactorGraph()
multi_variables = []
for i in range(length):
multi_variable = factor_graph.create_multi_variable(2)
multi_variable[0] = 0
multi_variable[1] = var_log_potentials[i]
multi_variables.append(multi_variable)
# generate sequence log potentials
initials = np.zeros(2)
finals = np.zeros(2)
transitions = np.zeros((length - 1, 2, 2))
transitions[:, 1, 1] = rng.randn(length - 1)
edge_log_potentials = np.concatenate([initials,
transitions.ravel(),
finals])
import os
import itertools
from time import time
import numpy as np
from ad3 import PFactorGraph
from ad3.extensions import PFactorSequence
plot = False if os.environ.get('NOPLOT') else True
if plot:
import matplotlib.pyplot as plt
grid_size = 20
num_states = 5
factor_graph = PFactorGraph()
multi_variables = []
random_grid = np.random.uniform(size=(grid_size, grid_size, num_states))
for i in range(grid_size):
multi_variables.append([])
for j in range(grid_size):
new_variable = factor_graph.create_multi_variable(num_states)
for state in range(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()
print("Randomly picked tree:", parents)
# Design number of states for each node.
num_states = rng.randint(1, max_num_states + 1, size=num_nodes)
print("States per node:", num_states)
# generate random potentials
var_log_potentials = [rng.randn(n) for n in num_states]
edge_log_potentials = [
rng.randn(num_states[parents[i]] * num_states[i])
for i in range(1, num_nodes)
]
# 1) Build a factor graph using DENSE factors.
pairwise_fg = PFactorGraph()
multi_variables = []
for i in range(num_nodes):
var = pairwise_fg.create_multi_variable(num_states[i])
var.set_log_potentials(var_log_potentials[i])
multi_variables.append(var)
description = ''
num_factors = 0
for i in range(1, num_nodes):
p = parents[i]
edge_variables = [multi_variables[p], multi_variables[i]]
pairwise_fg.create_factor_dense(edge_variables, edge_log_potentials[i - 1])
num_factors += 1
import os
import itertools
from time import time
import numpy as np
from ad3 import PFactorGraph
from ad3.extensions import PFactorSequence
plot = False if os.environ.get('NOPLOT') else True
if plot:
import matplotlib.pyplot as plt
grid_size = 20
num_states = 5
factor_graph = PFactorGraph()
multi_variables = []
random_grid = np.random.uniform(size=(grid_size, grid_size, num_states))
for i in range(grid_size):
multi_variables.append([])
for j in range(grid_size):
new_variable = factor_graph.create_multi_variable(num_states)
for state in range(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()
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 = 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.