def __init__(self, check_array):
self._factornodes = []
self._variablenodes = []
n = check_array.shape[0]
m = check_array.shape[1]
for i in xrange(m):
self._variablenodes.append(VariableNode('v' + str(i)))
for i in xrange(n):
fnode = FactorNode('f' + str(i))
self._factornodes.append(fnode)
check_array_row = check_array[i, :]
for j, a in enumerate(check_array_row):
if a:
vnode = self._variablenodes[j]
fnode.add_undirected_connection(vnode)
def __init__(self, check_array):
self._factornodes = []
self._variablenodes = []
n = check_array.shape[0]
m = check_array.shape[1]
for i in xrange(m):
self._variablenodes.append(VariableNode('v' + str(i)))
for i in xrange(n):
fnode = FactorNode('f' + str(i))
self._factornodes.append(fnode)
check_array_row = check_array[i, :]
for j, a in enumerate(check_array_row):
if a:
vnode = self._variablenodes[j]
fnode.add_undirected_connection(vnode)
def createExerciseGraph():
C = VariableNode("C")
T = VariableNode("T")
A = VariableNode("A")
M = VariableNode("M")
J = VariableNode("J")
fC = FactorNode("fC", [0.999, 0.001], C)
fCTA = FactorNode(
"fACT", [[[0.999, 0.71], [0.06, 0.05]], [[0.001, 0.29], [0.94, 0.95]]],
A, C, T)
fT = FactorNode("fT", [0.998, 0.002], T)
fMA = FactorNode("fMA", [[0.95, 0.1], [0.05, 0.9]], M, A)
fJA = FactorNode("fJA", [[0.99, 0.3], [0.01, 0.7]], J, A)
graph = Graph()
graph.addVariableNode(C)
graph.addFactorNode(fCTA)
graph.addVariableNode(T)
graph.addVariableNode(A)
graph.addFactorNode(fMA)
graph.addVariableNode(M)
graph.addFactorNode(fJA)
graph.addVariableNode(J)
graph.addFactorNode(fC)
graph.addFactorNode(fT)
return graph
def test_factornode_message_generation_BEC(self):
f1 = FactorNode()
m1 = BinaryMessage(1, 'a')
m2 = BinaryMessage(-1, 'b')
m3 = BinaryMessage(0, 'c')
f1._recieve_message(m1)
f1._recieve_message(m2)
f1._recieve_message(m3)
b1 = f1.generate_BEC_message_for('a')
b2 = f1.generate_BEC_message_for('b')
b3 = f1.generate_BEC_message_for('c')
self.assertEquals(0, b1.data)
self.assertEquals(0, b2.data)
self.assertEquals(-1, b3.data)
def test_factornode_message_generation_BEC(self):
f1 = FactorNode()
m1 = BinaryMessage(1, 'a')
m2 = BinaryMessage(-1, 'b')
m3 = BinaryMessage(0, 'c')
f1._recieve_message(m1)
f1._recieve_message(m2)
f1._recieve_message(m3)
b1 = f1.generate_BEC_message_for('a')
b2 = f1.generate_BEC_message_for('b')
b3 = f1.generate_BEC_message_for('c')
self.assertEquals(0, b1.data)
self.assertEquals(0, b2.data)
self.assertEquals(-1, b3.data)
import numpy as np
fg = FactorGraph()
a = VarNode(name='a', graph=fg)
b = VarNode(name='b', graph=fg)
c = VarNode(name='c', init=[1., 1., 1.], graph=fg)
f1_cpd = np.array([[2, 3],
[6, 4]])
f2_cpd = np.array([[7, 2, 3],
[1, 5, 2]])
f3_cpd = np.array([[7, 9, 3],
[6, 4, 2]])
f1 = FactorNode(cpd=f1_cpd, graph=fg, name='f1', ordered_variables=(a, b))
f2 = FactorNode(cpd=f2_cpd, graph=fg, name='f2', ordered_variables=(a, c))
f3 = FactorNode(cpd=f3_cpd, graph=fg, name='f3', ordered_variables=(b, c))
fg.add_var_nodes([a, b, c])
fg.add_factor_nodes([f1, f2, f3])
fg.add_edge(a, f1)
fg.add_edge(f1, b)
fg.add_edge(b, f3)
fg.add_edge(f3, c)
fg.add_edge(a, f2)
fg.add_edge(f2, c)
pos = {a: (-3, 0), b: (0, 3), c: (3, 0), f1: (-1.5, 1.5), f2: (0, 0), f3: (1.5, 1.5)}
fg.save_graph_fig(num=1, pos=pos)
# fg.sum_product(node=b)
fg.loopy_sum_product(iterations=20, epsilon=1e-5, plot_errors=True)
def addFactorNode(self, id, array, *args):
factorNode = FactorNode(id, array, *args)
self.factorNodes.append(factorNode)
def add_factor_node(self, P, *args):
factor_id = len(self.factors)
factor = FactorNode(P, factor_id, *args)
self.factors.append(factor)
return factor
from factor_graph import FactorGraph
from node import VarNode, FactorNode
import numpy as np
fg = FactorGraph()
params = {'graph': fg}
x1 = VarNode(name='x1', **params)
x2 = VarNode(name='x2', **params)
x3 = VarNode(name='x3', **params)
x4 = VarNode(name='x4', **params)
cpd_a = np.array([[3, 4], [3, 9]])
cpd_b = np.array([[3, 4], [5, 1]])
cpd_c = np.array([[7, 8], [3, 9]])
fa = FactorNode(cpd_a, (x1, x2), name='fa', **params)
fb = FactorNode(cpd_b, (x2, x3), name='fb', **params)
fc = FactorNode(cpd_c, (x2, x4), name='fc', **params)
fg.add_var_nodes([x1, x2, x3, x4])
fg.add_factor_nodes([fa, fb, fc])
fg.add_edge(x1, fa)
fg.add_edge(fa, x2)
fg.add_edge(x2, fb)
fg.add_edge(fb, x3)
fg.add_edge(x2, fc)
fg.add_edge(fc, x4)
print(fg.nodes)
print(fg.neighbors(x4))
def add_factor_node(self, joint_prob, *args):
factor_id = len(self.factors)
factorNode = FactorNode(joint_prob, factor_id, *args)
self.factors.append(factorNode)
return factorNode
