def setUp(self): nodedata = NodeData.load("unittestlgdict.txt") skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() self.lgb = LGBayesianNetwork(nodedata)
def setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData.load("unittestdict.txt") self.bn = DiscreteBayesianNetwork(nodedata) self.fn = TableCPDFactorization(self.bn)
def setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData() nodedata.load("unittestdict.txt") self.instance = DiscreteBayesianNetwork(skel, nodedata)
def setUp(self): self.nd = NodeData() self.nd.load("unittestdyndict.txt") self.skel = GraphSkeleton() self.skel.load("unittestdyndict.txt") self.skel.toporder() self.d = DynDiscBayesianNetwork(self.skel, self.nd)
def setUp(self): self.nd = HybridNodeData.load("unittesthdict.txt") self.nd.entriestoinstances() self.skel = GraphSkeleton() self.skel.load("unittestdict.txt") self.skel.toporder() self.hybn = HyBayesianNetwork(self.skel, self.nd)
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 setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData.load("unittestdict.txt") self.instance = DiscreteBayesianNetwork(nodedata) self.factor = TableCPDFactor("Grade", self.instance) self.factor2 = TableCPDFactor("Letter", self.instance)
def getTableCPD(): nd = NodeData() skel = GraphSkeleton() jsonpath = "" nd.load(jsonpath) skel.load(jsonpath) bn = DiscreteBayesianNetwork(skel, nd) tablecpd = TableCPDFactorization(bn) return tablecpd
def test_hybn_mte_estimateparams(self): skel = GraphSkeleton() skel.load("../tests/bn_skeleton.txt") skel.toporder() with open('../tests/dataBR2.json', 'r') as f: samples = eval(f.read()) result = self.l.hybn_mte_estimateparams(self.skel, self.samplelgseq)
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 getTableCPD(): nd = NodeData() skel = GraphSkeleton() jsonpath = "./graph/graph_example.txt" nd.load(jsonpath) skel.load(jsonpath) # load Bayesian network bn = DiscreteBayesianNetwork(skel, nd) tablecpd = TableCPDFactorization(bn) return tablecpd
def test_libpgm(df1): data = df1.T.to_dict().values() #pprint(data) skel = GraphSkeleton() skel.load("bn_struct.txt") learner = PGMLearner() result = learner.discrete_mle_estimateparams(skel, data) print json.dumps(result.Vdata, indent=2)
class TestOrderedSkeleton(unittest.TestCase): def setUp(self): self.os = OrderedSkeleton() self.os.load("unittestdict.txt") self.gs = GraphSkeleton() self.gs.load("unittestdict.txt") def test_constructor(self): self.assertNotEqual(self.os.V, self.gs.V) self.gs.toporder() self.assertEqual(self.os.V, self.gs.V)
def getTableCPD(): nd = NodeData() skel = GraphSkeleton() jsonpath = "job_interview.txt" nd.load(jsonpath) skel.load(jsonpath) #load bayesian network bn = DiscreteBayesianNetwork(skel, nd) tablecpd = TableCPDFactorization(bn) return tablecpd
def load(self, file_name): #### Load BN nd = NodeData() skel = GraphSkeleton() nd.load(file_name) # any input file skel.load(file_name) # topologically order graphskeleton skel.toporder() super(DiscreteBayesianNetworkExt, self).__init__(skel, nd) ##TODO load evidence
class TestDynDiscBayesianNetwork(unittest.TestCase): def setUp(self): self.nd = NodeData.load("unittestdyndict.txt") self.skel = GraphSkeleton() self.skel.load("unittestdyndict.txt") self.skel.toporder() self.d = DynDiscBayesianNetwork(self.skel, self.nd) def test_randomsample(self): sample = self.d.randomsample(10) for i in range(1, 10): self.assertEqual(sample[0]['Difficulty'], sample[i]['Difficulty'])
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
class TestHyBayesianNetwork(unittest.TestCase): def setUp(self): self.nd = HybridNodeData.load("unittesthdict.txt") self.nd.entriestoinstances() self.skel = GraphSkeleton() self.skel.load("unittestdict.txt") self.skel.toporder() self.hybn = HyBayesianNetwork(self.skel, self.nd) def test_randomsample(self): sample = self.hybn.randomsample(1)[0] self.assertTrue(isinstance(sample['Grade'], float)) self.assertTrue(isinstance(sample['Intelligence'], str)) self.assertEqual(sample["SAT"][-12:], 'blueberries!')
def setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData.load("unittestdict.txt") self.bn = DiscreteBayesianNetwork(nodedata) agg = SampleAggregator() agg.aggregate(self.bn.randomsample(50)) self.rseq = agg.seq self.ravg = agg.avg self.fn = TableCPDFactorization(self.bn) evidence = dict(Letter='weak') agg.aggregate(self.fn.gibbssample(evidence, 51)) self.gseq = agg.seq self.gavg = agg.avg
def createData(): nd = NodeData() skel = GraphSkeleton() fpath = "job_interview.txt" nd.load(fpath) skel.load(fpath) skel.toporder() bn = DiscreteBayesianNetwork(skel, nd) learner = PGMLearner() data = bn.randomsample(1000) X, Y = 'Grades', 'Offer' c,p,w=learner.discrete_condind(data, X, Y, ['Interview']) print "independence between X and Y: ", c, " p-value ", p, " witness node: ", w result = learner.discrete_constraint_estimatestruct(data) print result.E
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)
class TestGraphSkeleton(unittest.TestCase): def setUp(self): self.instance = GraphSkeleton() self.instance.V = [1, 2, 3, 4, 5] self.instance.E = [[5, 1], [1, 2]] def test_getparents(self): self.assertEqual(self.instance.getparents(1), [5]) self.assertEqual(self.instance.getparents(4), []) def test_getchildren(self): self.assertEqual(self.instance.getchildren(5), [1]) self.assertEqual(self.instance.getchildren(4), []) def test_toporder(self): self.instance.toporder() self.assertTrue(self.instance.V.index(5) < self.instance.V.index(1)) self.assertTrue(self.instance.V.index(5) < self.instance.V.index(2))
def net2(): nd = NodeData() skel = GraphSkeleton() nd.load("net.txt") # an input file skel.load("net.txt") # topologically order graphskeleton skel.toporder() # load bayesian network lgbn = LGBayesianNetwork(skel, nd) in_data=read_data.getdata2() learner = PGMLearner() bn=learner.lg_mle_estimateparams(skel,in_data) p=cal_prob(in_data[300:500],bn) print p return 0
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
class TestGraphSkeleton(unittest.TestCase): def setUp(self): self.instance = GraphSkeleton() self.instance.V = [1,2,3,4,5] self.instance.E = [[5,1],[1,2]] def test_getparents(self): self.assertEqual(self.instance.getparents(1), [5]) self.assertEqual(self.instance.getparents(4), []) def test_getchildren(self): self.assertEqual(self.instance.getchildren(5), [1]) self.assertEqual(self.instance.getchildren(4), []) def test_toporder(self): self.instance.toporder() self.assertTrue(self.instance.V.index(5)<self.instance.V.index(1)) self.assertTrue(self.instance.V.index(5)<self.instance.V.index(2))
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 setUp(self): # instantiate learner self.l = PGMLearner() # generate graph skeleton skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() # generate sample sequence to try to learn from - discrete nd = NodeData.load("unittestdict.txt") self.samplediscbn = DiscreteBayesianNetwork(nd) self.samplediscseq = self.samplediscbn.randomsample(5000) # generate sample sequence to try to learn from - discrete nda = NodeData.load("unittestlgdict.txt") self.samplelgbn = LGBayesianNetwork(nda) self.samplelgseq = self.samplelgbn.randomsample(10000) self.skel = skel
def test_structure_estimation(self): req = DiscreteStructureEstimationRequest() skel = GraphSkeleton() skel.load(self.data_path) skel.toporder() teacher_nd = NodeData() teacher_nd.load(self.teacher_data_path) bn = DiscreteBayesianNetwork(skel, teacher_nd) data = bn.randomsample(8000) for v in data: gs = DiscreteGraphState() for k_s, v_s in v.items(): gs.node_states.append(DiscreteNodeState(node=k_s, state=v_s)) req.states.append(gs) res = self.struct_estimate(req) self.assertIsNotNone(res.graph) self.assertEqual(len(res.graph.nodes), 5) self.assertGreater(len(res.graph.edges), 0)
def set_bayesnet(self): nd = NodeData() skel = GraphSkeleton() nd.load(self.file) skel.load(self.file) skel.toporder() self.bn = DiscreteBayesianNetwork(skel, nd)
def buildBN(trainingData, binstyleDict, numbinsDict, **kwargs): # need to modify to accept skel or skelfile discretized_training_data, bin_ranges = discretizeTrainingData( trainingData, binstyleDict, numbinsDict, True) print 'discret training ', discretized_training_data if 'skel' in kwargs: # load file into skeleton if isinstance(kwargs['skel'], basestring): skel = GraphSkeleton() skel.load(kwargs['skel']) skel.toporder() else: skel = kwargs['skel'] # learn bayesian network learner = PGMLearner() # baynet = learner.discrete_mle_estimateparams(skel, discretized_training_data) # baynet = discrete_estimatebn(learner, discretized_training_data, skel, 0.05, 1) baynet = discrete_mle_estimateparams2( skel, discretized_training_data ) # using discrete_mle_estimateparams2 written as function in this file, not calling from libpgm return baynet
def main(): in_data=read_data.getdata() f_data=format_data(in_data) nd = NodeData() nd.load("net4.txt") # an input file skel = GraphSkeleton() skel.load("net4.txt") skel.toporder() bn=DiscreteBayesianNetwork(skel,nd) #training dataset:70% bn2=em(f_data[1:6000],bn,skel) pr_training = precision(f_data[1:6000],bn2) print "Prediction accuracy for training data:" , pr_training[1] #testing dataset:30% pr=precision(f_data[6700:6800],bn2) print "Prediction accuracy for test data:", pr[1]
def test_param_estimation(self): req = DiscreteParameterEstimationRequest() # load graph structure skel = GraphSkeleton() skel.load(self.data_path) req.graph.nodes = skel.V req.graph.edges = [GraphEdge(k, v) for k,v in skel.E] skel.toporder() # generate trial data teacher_nd = NodeData() teacher_nd.load(self.teacher_data_path) bn = DiscreteBayesianNetwork(skel, teacher_nd) data = bn.randomsample(200) for v in data: gs = DiscreteGraphState() for k_s, v_s in v.items(): gs.node_states.append(DiscreteNodeState(node=k_s, state=v_s)) req.states.append(gs) self.assertEqual(len(self.param_estimate(req).nodes), 5)
def setup(self): self.nd = NodeData() self.skel = GraphSkeleton() self.skel.V, self.skel.E = [], [] self.nd.Vdata = {} for i, node in enumerate(self.node.values()): dNode = {} node.sId = str(i) dNode["numoutcomes"] = len(node.values) dNode["vals"] = node.values dNode["cprob"] = node.cpt # dNode["parents"] = map(lambda x: if x=x.name, node.parents); self.skel.V.append(node.name) aParents = [] for parent in node.parents: if parent == None: continue aParents.append(parent.name) self.skel.E.append([parent.name, node.name]) dNode["parents"] = aParents if len(aParents) > 0 else None self.nd.Vdata[node.name] = dNode self.skel.toporder() self.bn = DiscreteBayesianNetwork(self.skel, self.nd) self.fn = TableCPDFactorization(self.bn)
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 load(self, file_name): #### Load BN nd = NodeData() skel = GraphSkeleton() nd.load(file_name) # any input file skel.load(file_name) # topologically order graphskeleton skel.toporder() super(DiscreteBayesianNetworkExt, self).__init__(skel, nd)
def learnBN(fdata_array, bn_file): bn_path = os.path.join(experiment_dir, 'parameters', bn_file + '.txt') skel = GraphSkeleton() skel.load(bn_path) skel.toporder() learner = PGMLearner() bn = learner.discrete_mle_estimateparams(skel, fdata_array) return bn
def loadbn(param_file): """ This function loads the bn model into the workspace from its associated .txt file. """ file_path = os.path.join(experiment_dir, 'parameters', param_file + '.txt') nd = NodeData() skel = GraphSkeleton() nd.load(file_path) skel.load(file_path) skel.toporder() bn = DiscreteBayesianNetwork(skel, nd) return bn
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 net2(): nd = NodeData() skel = GraphSkeleton() nd.load("net.txt") # an input file skel.load("net.txt") # topologically order graphskeleton skel.toporder() # load bayesian network lgbn = LGBayesianNetwork(skel, nd) in_data = read_data.getdata2() learner = PGMLearner() bn = learner.lg_mle_estimateparams(skel, in_data) p = cal_prob(in_data[300:500], bn) print p return 0
def main(): in_data = read_data.getdata() f_data = format_data(in_data) nd = NodeData() nd.load("net4.txt") # an input file skel = GraphSkeleton() skel.load("net4.txt") skel.toporder() bn = DiscreteBayesianNetwork(skel, nd) #training dataset:70% bn2 = em(f_data[1:6000], bn, skel) pr_training = precision(f_data[1:6000], bn2) print "Prediction accuracy for training data:", pr_training[1] #testing dataset:30% pr = precision(f_data[6700:6800], bn2) print "Prediction accuracy for test data:", pr[1]
import sys import string from libpgm.graphskeleton import GraphSkeleton from libpgm.tablecpdfactorization import TableCPDFactorization from libpgm.pgmlearner import PGMLearner text = open("../unifiedMLData2.json") data=text.read() printable = set(string.printable) asciiData=filter(lambda x: x in printable, data) listofDicts=json.loads(asciiData) skel = GraphSkeleton() skel.load("../skeleton.json") learner = PGMLearner() result = learner.discrete_mle_estimateparams(skel, listofDicts) tcf=TableCPDFactorization(result) #Rating 1 Given Genre is Drama myquery = dict(rating=[1]) myevidence = dict(genre='Drama') result=tcf.specificquery(query=myquery,evidence=myevidence) print result
def Threshold(list): temp = [] #temp.append(min(list)+float(max(list) - min(list))*1/3) #temp.append(min(list)+float(max(list) - min(list))*2/3) temp.append(float(max(list))/3) temp.append(float(max(list))/3*2) return temp EachLikeThreshold = Threshold(EachLike) EachLikedThreshold = Threshold(EachLiked) print EachLikeThreshold print EachLikedThreshold BulliedPro = [] nd = NodeData() skel = GraphSkeleton() nd.load('unittestdict.txt') skel.load('unittestdict.txt') bn = DiscreteBayesianNetwork(skel, nd) fn = TableCPDFactorization(bn) for i in range(len(EachLike)): evidence = {} if EachLike[i] <= EachLikeThreshold[0]: evidence['LikeN'] = 'Small' elif EachLikeThreshold[0] < EachLike[i] and EachLike[i] <= EachLikeThreshold[1]: evidence['LikeN'] = 'Mid' else: evidence['LikeN'] = 'Big' if EachLiked[i] <= EachLikedThreshold[0]: evidence['LikedN'] = 'Small'
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 setUp(self): self.os = OrderedSkeleton() self.os.load("unittestdict.txt") self.gs = GraphSkeleton() self.gs.load("unittestdict.txt")
data_l = [] for line in data_r.readlines(): data_l.append(map(int, line.split())) truth_l = [] for row in truth_r: truth_l.append(row[0]) w = csv.writer(open("bayesian_outcome.txt", "wb")) count = 0 for i in range(104): nd = NodeData() skel = GraphSkeleton() nd.load('bayes_net/'+str(i)+".txt") # any input file skel.load('bayes_net/'+str(i)+".txt") # topologically order graphskeleton skel.toporder() # load bayesian network # load bayesian network bn = DiscreteBayesianNetwork(skel, nd) dic1 = {} k = 1 for c in data_l[i]: dic1[str(k)] = str(c) k += 2
def setUp(self): self.instance = GraphSkeleton() self.instance.V = [1,2,3,4,5] self.instance.E = [[5,1],[1,2]]
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