def BNskelFromCSV(csvdata, targets):
#TODO: must know how to swap direction of too many inputs into a node
######## EXTRACT HEADER STRINGS FROM CSV FILE ########
skel = GraphSkeleton()
BNstructure = {}
inputVerts = []
# if data is a filepath
if isinstance(csvdata, basestring):
dataset = []
with open(csvdata, 'rb') as csvfile:
lines = csv.reader(csvfile)
for row in lines:
dataset.append(row)
allVertices = dataset[0]
else:
allVertices = csvdata[0]
BNstructure['V'] = allVertices
skel.V = allVertices
for verts in allVertices:
if verts not in targets:
inputVerts.append(verts)
#target, each input
edges = []
if len(inputVerts) > len(targets):
for target in targets:
for input in inputVerts:
edge = [target, input]
edges.append(edge)
BNstructure['E'] = edges
skel.E = edges
else:
for input in inputVerts:
for target in targets:
edge = [input, target]
edges.append(edge)
BNstructure['E'] = edges
skel.E = edges
skel.toporder()
return skel
def graph_skeleton_from_node_data(nd):
skel = GraphSkeleton()
skel.V = []
skel.E = []
for name, v in nd.Vdata.items():
skel.V += [name]
skel.E += [[name, c] for c in v["children"]]
return skel
def graph_skeleton_from_node_data(nd):
skel = GraphSkeleton()
skel.V = []
skel.E = []
for name, v in nd.Vdata.items():
skel.V += [name]
skel.E += [[name, c] for c in v["children"]]
return skel
def q_without_ros():
skel = GraphSkeleton()
skel.V = ["prize_door", "guest_door", "monty_door"]
skel.E = [["prize_door", "monty_door"],
["guest_door", "monty_door"]]
skel.toporder()
nd = NodeData()
nd.Vdata = {
"prize_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0/3, 1.0/3, 1.0/3],
},
"guest_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0/3, 1.0/3, 1.0/3],
},
"monty_door": {
"numoutcomes": 3,
"parents": ["prize_door", "guest_door"],
"children": None,
"vals": ["A", "B", "C"],
"cprob": {
"['A', 'A']": [0., 0.5, 0.5],
"['B', 'B']": [0.5, 0., 0.5],
"['C', 'C']": [0.5, 0.5, 0.],
"['A', 'B']": [0., 0., 1.],
"['A', 'C']": [0., 1., 0.],
"['B', 'A']": [0., 0., 1.],
"['B', 'C']": [1., 0., 0.],
"['C', 'A']": [0., 1., 0.],
"['C', 'B']": [1., 0., 0.],
},
},
}
bn = DiscreteBayesianNetwork(skel, nd)
fn = TableCPDFactorization(bn)
query = {
"prize_door": ["A","B","C"],
}
evidence = {
"guest_door": "A",
"monty_door": "B",
}
res = fn.condprobve(query, evidence)
print res.vals
print res.scope
print res.card
print res.stride
def q_without_ros():
skel = GraphSkeleton()
skel.V = ["prize_door", "guest_door", "monty_door"]
skel.E = [["prize_door", "monty_door"], ["guest_door", "monty_door"]]
skel.toporder()
nd = NodeData()
nd.Vdata = {
"prize_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0 / 3, 1.0 / 3, 1.0 / 3],
},
"guest_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0 / 3, 1.0 / 3, 1.0 / 3],
},
"monty_door": {
"numoutcomes": 3,
"parents": ["prize_door", "guest_door"],
"children": None,
"vals": ["A", "B", "C"],
"cprob": {
"['A', 'A']": [0., 0.5, 0.5],
"['B', 'B']": [0.5, 0., 0.5],
"['C', 'C']": [0.5, 0.5, 0.],
"['A', 'B']": [0., 0., 1.],
"['A', 'C']": [0., 1., 0.],
"['B', 'A']": [0., 0., 1.],
"['B', 'C']": [1., 0., 0.],
"['C', 'A']": [0., 1., 0.],
"['C', 'B']": [1., 0., 0.],
},
},
}
bn = DiscreteBayesianNetwork(skel, nd)
fn = TableCPDFactorization(bn)
query = {
"prize_door": ["A", "B", "C"],
}
evidence = {
"guest_door": "A",
"monty_door": "B",
}
res = fn.condprobve(query, evidence)
print res.vals
print res.scope
print res.card
print res.stride
def getBNparams(graph, ddata, n):
# Gets Disc. BN parameters given a graph skeleton
#skeleton should include t-1 and t nodes for each variable
nodes = range(1, (n * 2) + 1)
nodes = map(str, nodes)
edges = gk.edgelist(graph)
for i in range(len(edges)):
edges[i] = list([edges[i][0], str(n + int(edges[i][1]))])
skel = GraphSkeleton()
skel.V = nodes
skel.E = edges
learner = PGMLearner()
result = learner.discrete_mle_estimateparams(skel, ddata)
return result
def add_sensor(self, sensor_keys):
for key in sensor_keys:
network_file = open(self.dbn_file_name, 'r')
network_file_data = eval(network_file.read())
network_skeleton = GraphSkeleton()
network_skeleton.V = network_file_data["V"]
network_skeleton.E = network_file_data["E"]
self.network = DynDiscBayesianNetwork()
self.network.V = network_skeleton.V
self.network.E = network_skeleton.E
self.network.initial_Vdata = network_file_data["initial_Vdata"]
self.network.twotbn_Vdata = network_file_data["twotbn_Vdata"]
self.inference_engines[key] = SensorDbnInferenceEngine(self.network)
def construct(self):
skel = GraphSkeleton()
skel.V = self.nodes.keys()
skel.E = []
for node, ndata in self.nodes.iteritems():
if ndata['parents']:
for p in ndata['parents']:
skel.E.append([p, node])
self.nodes[p]['children'].append(node)
for node, ndata in self.nodes.iteritems():
if len(ndata['children']) == 0:
ndata['children'] = None
data = NodeData()
data.Vdata = self.nodes
skel.toporder()
bn = DiscreteBayesianNetwork(skel, data)
return bn
def ConstructDynBN(num_graph, numvalues, A, ss):
graph = conv.ian2g(num_graph)
print(graph)
V, E, initVdata = INITdata(graph, numvalues)
tfVdata = gettfVdata(num_graph, numvalues, A)
d = DynDiscBayesianNetwork()
skel = GraphSkeleton()
skel.V = V
skel.E = E
d.V = skel.V
d.E = skel.E
d.initial_Vdata = initVdata
d.twotbn_Vdata = tfVdata
print(d.V)
print(d.E)
print(d.initial_Vdata)
print(d.twotbn_Vdata)
data = sampleBN(d, ss)
return data
def learnDiscreteBN_with_structure(df,
continous_columns,
features_column_names,
label_column='cat',
draw_network=False):
features_df = df.copy()
features_df = features_df.drop(label_column, axis=1)
labels_df = DataFrame()
labels_df[label_column] = df[label_column].copy()
for i in continous_columns:
bins = np.arange((min(features_df[i])), (max(features_df[i])),
((max(features_df[i]) - min(features_df[i])) / 5.0))
features_df[i] = pandas.np.digitize(features_df[i], bins=bins)
data = []
for index, row in features_df.iterrows():
dict = {}
for i in features_column_names:
dict[i] = row[i]
dict[label_column] = labels_df[label_column][index]
data.append(dict)
print "Init done"
learner = PGMLearner()
graph = GraphSkeleton()
graph.V = []
graph.E = []
graph.V.append(label_column)
for vertice in features_column_names:
graph.V.append(vertice)
graph.E.append([vertice, label_column])
test = learner.discrete_mle_estimateparams(graphskeleton=graph, data=data)
print "done learning"
edges = test.E
vertices = test.V
probas = test.Vdata
# print probas
dot_string = 'digraph BN{\n'
dot_string += 'node[fontname="Arial"];\n'
dataframes = {}
print "save data"
for vertice in vertices:
print "New vertice: " + str(vertice)
dataframe = DataFrame()
pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(probas[vertice])
dot_string += vertice.replace(
" ", "_") + ' [label="' + vertice + '\n' + '" ]; \n'
if len(probas[vertice]['parents']) == 0:
dataframe['Outcome'] = None
dataframe['Probability'] = None
vertex_dict = {}
for index_outcome, outcome in enumerate(probas[vertice]['vals']):
vertex_dict[str(
outcome)] = probas[vertice]["cprob"][index_outcome]
od = collections.OrderedDict(sorted(vertex_dict.items()))
# print "Vertice: " + str(vertice)
# print "%-7s|%-11s" % ("Outcome", "Probability")
# print "-------------------"
for k, v in od.iteritems():
# print "%-7s|%-11s" % (str(k), str(round(v, 3)))
dataframe.loc[len(dataframe)] = [k, v]
dataframes[vertice] = dataframe
else:
# pp.pprint(probas[vertice])
dataframe['Outcome'] = None
vertexen = {}
for index_outcome, outcome in enumerate(probas[vertice]['vals']):
temp = []
for parent_index, parent in enumerate(
probas[vertice]["parents"]):
# print str([str(float(index_outcome))])
temp = probas[vertice]["cprob"]
dataframe[parent] = None
vertexen[str(outcome)] = temp
dataframe['Probability'] = None
od = collections.OrderedDict(sorted(vertexen.items()))
# [str(float(i)) for i in ast.literal_eval(key)]
# str(v[key][int(float(k))-1])
# print "Vertice: " + str(vertice) + " with parents: " + str(probas[vertice]['parents'])
# print "Outcome" + "\t\t" + '\t\t'.join(probas[vertice]['parents']) + "\t\tProbability"
# print "------------" * len(probas[vertice]['parents']) *3
# pp.pprint(od.values())
counter = 0
# print number_of_cols
for outcome, cprobs in od.iteritems():
for key in cprobs.keys():
array_frame = []
array_frame.append((outcome))
print_string = str(outcome) + "\t\t"
for parent_value, parent in enumerate(
[i for i in ast.literal_eval(key)]):
# print "parent-value:"+str(parent_value)
# print "parten:"+str(parent)
array_frame.append(int(float(parent)))
# print "lengte array_frame: "+str(len(array_frame))
print_string += parent + "\t\t"
array_frame.append(cprobs[key][counter])
# print "lengte array_frame (2): "+str(len(array_frame))
# print cprobs[key][counter]
print_string += str(cprobs[key][counter]) + "\t"
# for stront in [str(round(float(i), 3)) for i in ast.literal_eval(key)]:
# print_string += stront + "\t\t"
# print "print string: " + print_string
# print "array_frame:" + str(array_frame)
dataframe.loc[len(dataframe)] = array_frame
counter += 1
print "Vertice " + str(vertice) + " done"
dataframes[vertice] = dataframe
for edge in edges:
dot_string += edge[0].replace(" ", "_") + ' -> ' + edge[1].replace(
" ", "_") + ';\n'
dot_string += '}'
# src = Source(dot_string)
# src.render('../data/BN', view=draw_network)
# src.render('../data/BN', view=False)
print "vizualisation done"
return dataframes
# figure.add_subplot(1,2,2)
# plt.scatter(test_data[cluster_1,0], test_data[cluster_1,1], c= 'r', marker='o')
# plt.scatter(test_data[cluster_2,0], test_data[cluster_2,1], c='b', marker='o')
# plt.scatter(test_data[cluster_3,0], test_data[cluster_3,1], c='k', marker='o')
# plt.scatter(means[:,0], means[:,1], c='c', marker='o')
# plt.show()
means = numpy.array([[ 2.00755688e-04, 1.65181639e-01], [ 8.37884753e-01, 9.99778286e-01], [ 9.75317567e-01, 2.46051178e-02]])
# sensor network
sensor_network_file = open('test_bayesian_networks/graph_sensor_dbn.txt', 'r')
sensor_network_file_data = eval(sensor_network_file.read())
sensor_network_skeleton = GraphSkeleton()
sensor_network_skeleton.V = sensor_network_file_data["V"]
sensor_network_skeleton.E = sensor_network_file_data["E"]
sensor_network = DynDiscBayesianNetwork()
sensor_network.V = sensor_network_skeleton.V
sensor_network.E = sensor_network_skeleton.E
sensor_network.initial_Vdata = sensor_network_file_data["initial_Vdata"]
sensor_network.twotbn_Vdata = sensor_network_file_data["twotbn_Vdata"]
# observation_network
observation_network_file = open('test_bayesian_networks/graph_transition_dbn.txt', 'r')
observation_network_file_data = eval(observation_network_file.read())
observation_network_skeleton = GraphSkeleton()
observation_network_skeleton.V = observation_network_file_data["V"]
observation_network_skeleton.E = observation_network_file_data["E"]
def graph_skeleton_from_ros(graph_structure):
skel = GraphSkeleton()
skel.V = graph_structure.nodes
skel.E = [[e.node_from, e.node_to] for e in graph_structure.edges]
return skel
def graph_skeleton_from_ros(graph_structure):
skel = GraphSkeleton()
skel.V = graph_structure.nodes
skel.E = [[e.node_from, e.node_to] for e in graph_structure.edges]
return skel
def learnDiscreteBN_with_structure(df, continous_columns, features_column_names, label_column='cat',
draw_network=False):
features_df = df.copy()
features_df = features_df.drop(label_column, axis=1)
labels_df = DataFrame()
labels_df[label_column] = df[label_column].copy()
for i in continous_columns:
bins = np.arange((min(features_df[i])), (max(features_df[i])),
((max(features_df[i]) - min(features_df[i])) / 5.0))
features_df[i] = pandas.np.digitize(features_df[i], bins=bins)
data = []
for index, row in features_df.iterrows():
dict = {}
for i in features_column_names:
dict[i] = row[i]
dict[label_column] = labels_df[label_column][index]
data.append(dict)
print "Init done"
learner = PGMLearner()
graph = GraphSkeleton()
graph.V = []
graph.E = []
graph.V.append(label_column)
for vertice in features_column_names:
graph.V.append(vertice)
graph.E.append([vertice, label_column])
test = learner.discrete_mle_estimateparams(graphskeleton=graph, data=data)
print "done learning"
edges = test.E
vertices = test.V
probas = test.Vdata
# print probas
dot_string = 'digraph BN{\n'
dot_string += 'node[fontname="Arial"];\n'
dataframes = {}
print "save data"
for vertice in vertices:
print "New vertice: " + str(vertice)
dataframe = DataFrame()
pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(probas[vertice])
dot_string += vertice.replace(" ", "_") + ' [label="' + vertice + '\n' + '" ]; \n'
if len(probas[vertice]['parents']) == 0:
dataframe['Outcome'] = None
dataframe['Probability'] = None
vertex_dict = {}
for index_outcome, outcome in enumerate(probas[vertice]['vals']):
vertex_dict[str(outcome)] = probas[vertice]["cprob"][index_outcome]
od = collections.OrderedDict(sorted(vertex_dict.items()))
# print "Vertice: " + str(vertice)
# print "%-7s|%-11s" % ("Outcome", "Probability")
# print "-------------------"
for k, v in od.iteritems():
# print "%-7s|%-11s" % (str(k), str(round(v, 3)))
dataframe.loc[len(dataframe)] = [k, v]
dataframes[vertice] = dataframe
else:
# pp.pprint(probas[vertice])
dataframe['Outcome'] = None
vertexen = {}
for index_outcome, outcome in enumerate(probas[vertice]['vals']):
temp = []
for parent_index, parent in enumerate(probas[vertice]["parents"]):
# print str([str(float(index_outcome))])
temp = probas[vertice]["cprob"]
dataframe[parent] = None
vertexen[str(outcome)] = temp
dataframe['Probability'] = None
od = collections.OrderedDict(sorted(vertexen.items()))
# [str(float(i)) for i in ast.literal_eval(key)]
# str(v[key][int(float(k))-1])
# print "Vertice: " + str(vertice) + " with parents: " + str(probas[vertice]['parents'])
# print "Outcome" + "\t\t" + '\t\t'.join(probas[vertice]['parents']) + "\t\tProbability"
# print "------------" * len(probas[vertice]['parents']) *3
# pp.pprint(od.values())
counter = 0
# print number_of_cols
for outcome, cprobs in od.iteritems():
for key in cprobs.keys():
array_frame = []
array_frame.append((outcome))
print_string = str(outcome) + "\t\t"
for parent_value, parent in enumerate([i for i in ast.literal_eval(key)]):
# print "parent-value:"+str(parent_value)
# print "parten:"+str(parent)
array_frame.append(int(float(parent)))
# print "lengte array_frame: "+str(len(array_frame))
print_string += parent + "\t\t"
array_frame.append(cprobs[key][counter])
# print "lengte array_frame (2): "+str(len(array_frame))
# print cprobs[key][counter]
print_string += str(cprobs[key][counter]) + "\t"
# for stront in [str(round(float(i), 3)) for i in ast.literal_eval(key)]:
# print_string += stront + "\t\t"
# print "print string: " + print_string
# print "array_frame:" + str(array_frame)
dataframe.loc[len(dataframe)] = array_frame
counter += 1
print "Vertice " + str(vertice) + " done"
dataframes[vertice] = dataframe
for edge in edges:
dot_string += edge[0].replace(" ", "_") + ' -> ' + edge[1].replace(" ", "_") + ';\n'
dot_string += '}'
# src = Source(dot_string)
# src.render('../data/BN', view=draw_network)
# src.render('../data/BN', view=False)
print "vizualisation done"
return dataframes
result = learner.discrete_estimatebn(data) # output - toggle comment to see #print json.dumps(result.E, indent=2) #print json.dumps(result.Vdata, indent=2) # (13) ----------------------------------------------------------------------- # Forward sample on dynamic Bayesian networks # read input file path = "../tests/unittestdyndict.txt" f = open(path, 'r') g = eval(f.read()) # set up dynamic BN d = DynDiscBayesianNetwork() skel = GraphSkeleton() skel.V = g["V"] skel.E = g["E"] skel.toporder() d.V = skel.V d.E = skel.E d.initial_Vdata = g["initial_Vdata"] d.twotbn_Vdata = g["twotbn_Vdata"] # forward sample seq = d.randomsample(10) # output - toggle comment to see #print json.dumps(seq, indent=2)
import json
from libpgm.nodedata import NodeData
from libpgm.graphskeleton import GraphSkeleton
from libpgm.dyndiscbayesiannetwork import DynDiscBayesianNetwork
from inference.sensor_dbn_inference import SensorDbnInference
network_file = open('test_bayesian_networks/sensor_dbn.txt', 'r')
network_file_data = eval(network_file.read())
network_skeleton = GraphSkeleton()
network_skeleton.V = network_file_data["V"]
network_skeleton.E = network_file_data["E"]
network = DynDiscBayesianNetwork()
network.V = network_skeleton.V
network.E = network_skeleton.E
network.initial_Vdata = network_file_data["initial_Vdata"]
network.twotbn_Vdata = network_file_data["twotbn_Vdata"]
inference_engine = SensorDbnInference(network)
print 'Initial belief: ', inference_engine.get_current_belief()
inference_engine.filter('1')
print 'Measurement = 1: ', inference_engine.get_current_belief()
inference_engine.filter('0')
print 'Measurement = 0: ', inference_engine.get_current_belief()
inference_engine.filter('0')
print 'Measurement = 0: ', inference_engine.get_current_belief()
result = learner.discrete_estimatebn(data) # output - toggle comment to see #print json.dumps(result.E, indent=2) #print json.dumps(result.Vdata, indent=2) # (13) ----------------------------------------------------------------------- # Forward sample on dynamic Bayesian networks # read input file path = "../tests/unittestdyndict.txt" f = open(path, 'r') g = eval(f.read()) # set up dynamic BN d = DynDiscBayesianNetwork() skel = GraphSkeleton() skel.V = g["V"] skel.E = g["E"] skel.toporder() d.V = skel.V d.E = skel.E d.initial_Vdata = g["initial_Vdata"] d.twotbn_Vdata = g["twotbn_Vdata"] # forward sample seq = d.randomsample(10) # output - toggle comment to see #print json.dumps(seq, indent=2)
