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): 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.load("unittestdict.txt") self.instance = DiscreteBayesianNetwork(nodedata) self.factor = TableCPDFactor("Grade", self.instance) self.factor2 = TableCPDFactor("Letter", self.instance)
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
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 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 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
class TestHyBayesianNetwork(unittest.TestCase): def setUp(self): self.nd = NodeData() self.nd.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!')
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 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 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
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 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
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 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 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 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 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]
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 print dic1 k = 2 * len(data_l[i]) - 2 dic2 = {} word = '' while k >= 0:
def train(self): """Train the associated module for one epoch.""" assert len(self.ds) > 0, "Dataset cannot be empty." gbds = [] ds2 = [] for seq in self.ds: for state_, action_, reward_ in seq: #sample = dict(theta=state_[0],thetaV=state_[1],s=state_[2],sV=state_[3],Action=action_[0],Reward=reward_[0]) sample = dict(StateA=state_[0],StateB=state_[2],StateC=state_[1],StateD=state_[3],Action=action_[0],Reward=reward_[0]) #print state_, action_, reward_ # sample = dict(StateA=state_[0],StateB=state_[2],StateC=state_[1],StateD=state_[3],Action=action_[0],Reward=reward_[0]) #sample = dict(theta=state_[0],thetaPrime=state_[2],s=state_[1],sPrime=state_[3],Action=action_[0],Reward=reward_[0]) if sample["Reward"] >= 0: gbds.append(sample) if sample["Reward"] == -1: ds2.append(sample) #print sample["Reward"] # sort samples for highest reward # bdss = sorted(gbds, key=lambda tup: tup["Reward"],reverse=True) # #print "BDS: " #print json.dumps(gbds, indent=2) # print "BDSS: " # print json.dumps(bdss, indent=2) #tokeep = bdss[:max(2,len(bdss)/2)] #print bds # estimate parameters # print "data size: ", len(bds), len(gbds) N = 200 if len(gbds) < N: l = N - len(gbds) n = len(ds2) t = len(ds2[n-l:]) gbds.extend(ds2[n-l:]) print "ds:, ", len(gbds), len(ds2) if len(gbds) < 100: # print "burn" self.module.burn = True return else: self.module.burn = False if len(gbds) < 5: #there was no rewarding action, so nothing to learn self.module.burn = True return N = 200 if len(gbds) > N: #only take the newest N samples l = len(gbds) gbds = gbds[l-N:] # print "new effective set", len(gbds) skel = GraphSkeleton() #load network topology skel.load("net2.txt") # skel.load("workfile") skel.toporder() # estimate parameters self.module.net = self.learner.lg_mle_estimateparams(skel, gbds)
import json from libpgm.nodedata import NodeData from libpgm.graphskeleton import GraphSkeleton from libpgm.lgbayesiannetwork import LGBayesianNetwork from libpgm.pgmlearner import PGMLearner # generate some data to use nd = NodeData() nd.load("gaussGrades.txt") # an input file skel = GraphSkeleton() skel.load("gaussGrades.txt") skel.toporder() lgbn = LGBayesianNetwork(skel, nd) data = lgbn.randomsample(8000) print data # instantiate my learner learner = PGMLearner() # estimate structure result = learner.lg_constraint_estimatestruct(data) # output print json.dumps(result.E, indent=2)
def fun(inputData): #Defining formatting data method def format_data(df): result = [] for row in df.itertuples(): #print(row.Pclass) result.append( dict(great=row.great, good=row.good, clean=row.clean, comfortable=row.comfortable, bad=row.bad, old=row.old, Cleanliness=row.Cleanliness, Location=row.Location, Service=row.Service, Rooms=row.Rooms, Value=row.Value, Overall=row.Overall)) return result #load all preprocessed training data df = pd.read_csv('features.csv', sep=',') #format data to let them correctly processed by libpgm functions node_data = format_data(df) skel = GraphSkeleton() #load structure of our net skel.load("./our-skel.txt") #setting the topologic order skel.toporder() #learner which will estimate parameters e if needed net structure learner = PGMLearner() #estismting parameters for our own model res = learner.discrete_mle_estimateparams(skel, node_data) # get CPT a = TableCPDFactorization(res) #compute the query and evidences as dicts query = dict(Overall=1) # prepare dictionary of values (dopo gli uguali devi mettere i valori che leggi dalla GUI) evidence = dict(Value=inputData[0], Location=inputData[1], Cleanliness=inputData[2], Service=inputData[3], Rooms=inputData[4], bad=inputData[5], old=inputData[6], good=inputData[7], great=inputData[8], comfortable=inputData[9], clean=inputData[10]) print(query) print(evidence) #run the query given evidence result = a.condprobve(query, evidence) print json.dumps(result.vals, indent=2) #res.Vdata["Overall"]["vals"][pos] #arr=[] dizionario = {} for i in range(1, 6): dizionario[res.Vdata["Overall"]["vals"][i - 1]] = result.vals[i - 1] # arr.append(dizionario) #print(str(arr)) return dizionario
def setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData.load("unittestdict.txt") self.instance = DiscreteBayesianNetwork(nodedata)
# result = learner.discrete_mle_estimateparams(skel, data) # # # output - toggle comment to see # print json.dumps(result.Vdata, indent=2) # (5) -------------------------------------------------------------------------- # Compute the probability distribution over a specific node or nodes # load nodedata and graphskeleton nd = NodeData() skel = GraphSkeleton() nd.load("../tests/unittestdict.txt") skel.load("../tests/unittestdict.txt") # toporder graph skeleton print skel.toporder() # load evidence evidence = {"Intelligence": "high"} query = {"Grade": "A"} # load bayesian network bn = DiscreteBayesianNetwork(skel, nd) # load factorization fn = TableCPDFactorization(bn) # # calculate probability distribution # result = fn.condprobve(query, evidence) # print json.dumps(result.vals, indent=2) # print json.dumps(result.scope, indent=2)
def bn_learn(attr, cicli, passed_file): path_to_sentiments = 'sentiment_AFINN' print "Using AFINN sentiment dictionary" if attr == 0: print "Considering tweets' number" elif attr == 1: print "Considering averaged number of positive, negative and neutral tweets" elif attr == 2: print "Considering averaged value of positive and negative tweets" elif attr == 3: print "Considering positive and negative tweets\' increment" elif attr == 4: print "Considering bullisment index obtained by number of tweets sentiment" elif attr == 5: print "Considering bullisment index obtained by tweets value of sentiment" print "And considering market trend" all_data = [] files = [ path_to_sentiments + "/" + file for file in os.listdir(path_to_sentiments) if file.endswith('.json') ] for file in files: with open(file) as sentiment_file: data = json.load(sentiment_file) vdata = {} if attr == 0: vdata["com"] = data["n_tweets"] elif attr == 1: vdata["pos"] = data["n_pos_ave"] vdata["neg"] = data["n_neg_ave"] vdata["neu"] = data["n_neu_ave"] elif attr == 2: vdata["pos"] = data["pos_val_ave"] vdata["neg"] = data["neg_val_ave"] elif attr == 3: vdata["pos"] = data["pos_inc"] vdata["neg"] = data["neg_inc"] elif attr == 4: vdata["com"] = data["bull_ind"] elif attr == 5: vdata["com"] = data["bull_ind_val"] vdata["market"] = data["market_inc"] all_data.append(vdata) skel = GraphSkeleton() if len(all_data[0]) == 2: skel.load("network_struct_1_vertex.json") print "Loading structure with 2 node" elif len(all_data[0]) == 3: skel.load("network_struct_2_vertex.json") print "Loading structure with 3 node" elif len(all_data[0]) == 4: skel.load("network_struct_3_vertex.json") print "Loading structure with 4 node" skel.toporder() learner = PGMLearner() result = learner.lg_mle_estimateparams(skel, all_data) for key in result.Vdata.keys(): result.Vdata[key]['type'] = 'lg' prob_pos = prob_neg = prob_neu = 0 for data in all_data: if data['market'] == 1: prob_pos += 1 elif data['market'] == 0: prob_neu += 1 else: prob_neg += 1 prob_pos = float(prob_pos) / float(len(all_data)) prob_neg = float(prob_neg) / float(len(all_data)) prob_neu = float(prob_neu) / float(len(all_data)) tmp = {} tmp['numoutcomes'] = len(all_data) tmp['cprob'] = [prob_pos, prob_neg, prob_neu] tmp['parents'] = result.Vdata['market']['parents'] tmp['vals'] = ['positive', 'negative', 'neutral'] tmp['type'] = 'discrete' tmp['children'] = result.Vdata['market']['children'] result.Vdata['market'] = tmp node = Discrete(result.Vdata["market"]) print "Loading node as Discrete" estimated, real = mcmc_json(passed_file, attr, cicli, node) return estimated, real
def learn(self): print "ds: ", len(self.dataset) #print self.dataset data = [] rw = [] bestreward = -100 for seq in self.dataset: for state_, action_, reward_ in seq: if reward_[0] > bestreward: bestreward = reward_[0] # find limit for theta print "bestrw", bestreward nds = [] lt=[] ls = [] ltv =[] lsv=[] i = 0 for seq in self.dataset: for state_, action_, reward_ in seq: # if reward_[0] == 0: # print state_, action_, reward_ #print state_, reward_ if reward_[0] == bestreward: ns = (state_, action_[0], reward_[0]) nds.append(ns) # print state_[0], state_[2], reward_[0], bestreward t = state_[0] tv= state_[1] s = state_[2] sv = state_[3] if t > 0.05: print "hmmm,", i, t #raise Exception(i) i += 1 lt.append(t) ls.append(s) ltv.append(tv) lsv.append(sv) limits = dict(theta=[min(lt),max(lt)],s=[min(ls),max(ls)],thetaV=[min(ltv),max(ltv)],sV=[min(lsv),max(lsv)]) print "limits: ", limits # print "all good things:", nds #convert ds for seq in self.dataset: for state_, action_, reward_ in seq: # sample = dict(theta=state_[0],thetaPrime=state_[1],s=state_[2],sPrime=state_[3],Action=action_[0],Reward=reward_[0]) # # # dtpo = min( abs(sample["thetaPrime"] - limits["theta"][0]), abs(sample["thetaPrime"] - limits["theta"][1])) # dto = min( abs(sample["theta"] - limits["theta"][0]), abs(sample["theta"] - limits["theta"][1])) # dspo = min( abs(sample["sPrime"] - limits["s"][0]), abs(sample["sPrime"] - limits["s"][1])) # dso = min( abs(sample["s"] - limits["s"][0]), abs(sample["s"] - limits["s"][1])) # # #print dspo, dso # # netsample = dict(theta=sample["theta"],s=sample["s"],Action=sample["Action"],Reward=sample["Reward"]) # # did this action improve theta or s?? # if dtpo <= dto or dspo <= dso: #yes it did ## data.append(netsample) # rw.append(sample["Reward"]) sample = dict(theta=state_[0],thetaV=state_[1],s=state_[2],sV=state_[3],Action=action_[0],Reward=reward_[0]) #print state_, action_, reward_ #print sample if sample["Reward"] != 990: data.append(sample) if numpy.random.random() >= 9.1: continue import matplotlib.pyplot as plt import pandas as pd df = pd.DataFrame(rw) # print df # plt.figure() # df[0].diff().hist() # instantiate my learner learner = PGMLearner() # estimate parameters rbn = [] for i in range(0,1): result = learner.lg_constraint_estimatestruct(data,bins=10, pvalparam=0.05) rbn.append(result) print len(result.E), result.E result = rbn[0] # output - toggle comment to see print json.dumps(result.V, indent=2) print len(result.E), "Edges", result.E import pydot # this time, in graph_type we specify we want a DIrected GRAPH graph = pydot.Dot(graph_type='digraph') nd = {} for n in result.V: nd[n] = pydot.Node(n) graph.add_node(nd[n]) for e in result.E: graph.add_edge(pydot.Edge(nd[e[0]], nd[e[1]])) graph.write_png('eg.png') from IPython.display import Image Image('eg.png') f = open('workfile', 'w') f.write("{\n \"V\":") f.write(json.dumps(result.V)) f.write(",\n \"E\":") f.write(json.dumps(result.E)) f.write("}") f.close() skel = GraphSkeleton() skel.load("workfile") # topologically order graphskeleton skel.toporder() return
# checking if input from user was approppriate if set(userinput).issubset(dictionary): # initializing probabilities lists wkdayProbList = [] hourProbList = [] locatProbList = [] activProbList = [] #INITIALIZING BN 1 # load nodedata and graphskeleton nd1 = NodeData() skel1 = GraphSkeleton() nd1.load(path_bn1) skel1.load(path_bn1) skel1.toporder() # toporder graph skeleton #INITIALIZING BN 2 # load nodedata and graphskeleton nd2 = NodeData() skel2 = GraphSkeleton() nd2.load(path_bn2) skel2.load(path_bn2) skel2.toporder() # toporder graph skeleton # FINDING NEXT ACTIVITY ATTRIBUTES THROUGH INFERENCE ON BN 1 # wkday variable query evidence1 = dict(wkdayT0=userinput[0]) for i, item in enumerate(wkdayValsList): # loading bayesian network and factorization - needs to be done at every iteration bn1 = DiscreteBayesianNetwork(skel1, nd1)
class Graph: def __init__(self): self.node = dict() self.obs = dict() def addnode(self, node): self.node[node.name] = node def removeNode(self, name): if self.node.has_key(name): del self.node[name] def addobs(self, node, value): self.obs[node.name] = [node, value] def removeObs(self, name): if self.obs.has_key(name): del self.obs[name] 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 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 getPost(self, query, evidence): result = self.fn.specificquery(query, evidence) return result def write2dot(self, fname="graph.dot"): f = open(fname, "w") f.write("digraph G {\n") f.write("node[shape=circle, width=0.4];\n") for node in self.node.values(): l = "\"" + node.name + "\"" f.write(node.sId) if node in map(lambda x: x[0], self.obs): f.write("[label=" + l + ",style=filled,color=blue]") else: f.write("[label=" + l + "]") f.write(";\n") for parent in node.parents: if parent == None: continue f.write(parent.sId + " -> " + node.sId + ";\n") f.write("}") f.close() def write2pdf(self, fname="graph.pdf"): if ".pdf" in fname: fname = fname[:-4] pdfFile = fname + ".pdf" dotFile = fname + ".dot" self.write2dot(dotFile) call(['dot', '-Tpdf', dotFile, '-o', pdfFile])