def inferCustomerClasses(param_file, evidence_dir, year): """ This function uses the variable elimination algorithm from libpgm to infer the customer class of each AnswerID, given the evidence presented in the socio-demographic survey responses. It returns a tuple of the dataframe with the probability distribution over all classes for each AnswerID and the BN object. """ bn = loadbn(param_file) evidence, a_id = readEvidence(year, evidence_dir) query = {"customer_class": ''} cols = bn.Vdata.get('customer_class')['vals'] result = pd.DataFrame( columns=cols ) #create empty dataframe in which to store inferred probabilities count = 0 #set counter for e in evidence: bn = loadbn(param_file) fn = TableCPDFactorization(bn) try: inf = fn.condprobve(query, e) classprobs = list(inf.vals) result.loc[count] = classprobs count += 1 except: result.loc[count] = [None] * len(cols) count += 1 result['AnswerID'] = a_id result.set_index(keys='AnswerID', inplace=True) return result
def estimate_distrib(skel, samples, query, evidence): learner = PGMLearner() bayesnet = learner.discrete_mle_estimateparams(skel, samples) tablecpd = TableCPDFactorization(bayesnet) fac = tablecpd.condprobve(query, evidence) df2 = printdist(fac, bayesnet) return df2
def compute_vertex_marginal(self, v, evidence): """ :return: a dictionary with: state name -> marginal values ex. {"state1": 0.5, "state2": 0.5} """ query = {v: ''} vertex_marginals = {} states = self.get_states(v) if v in evidence: vals = [] s_evidence = evidence[v] for s in states: if s == s_evidence: vertex_marginals[s] = 1.0 else: vertex_marginals[s] = 0.0 # if query node. else: #marginal values fn = TableCPDFactorization(self.clone()) mar_vals = fn.condprobve(query, evidence) # Associate marginals with values for i in range(len(states)): vertex_marginals[states[i]] = mar_vals.vals[i] return vertex_marginals
def compute_vertex_marginal(self, v, evidence): """ :return: a dictionary with: state name -> marginal values ex. {"state1": 0.5, "state2": 0.5} """ query = {v: ''} vertex_marginals = {} states = self.get_states(v) if v in evidence: vals = [] s_evidence = evidence[v] for s in states: if s == s_evidence: vertex_marginals[s] = 1.0 else: vertex_marginals[s] = 0.0 # if query node. else: #marginal values fn = TableCPDFactorization(self.clone()) mar_vals = fn.condprobve(query, evidence) # Associate marginals with values for i in range(len(states)): vertex_marginals[states[i]] = mar_vals.vals[i] return vertex_marginals
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 classify(evidence, bn): #q1=dict(Speed=evidence['Speed']) q2 = dict(Volume=evidence['Volume']) # del evidence['Speed'] del evidence['Volume'] #fn = TableCPDFactorization(bn)#toolbx #result=fn.condprobve(q1,evidence)#t #mx=max(result.vals) #indx=result.vals.index(mx) #sp= bn.Vdata['Speed']['vals'][indx] fn = TableCPDFactorization(bn) #t result = fn.condprobve(q2, evidence) #t mx = max(result.vals) indx = result.vals.index(mx) vl = bn.Vdata['Volume']['vals'][indx] return [0, vl]
def classify(evidence,bn): #q1=dict(Speed=evidence['Speed']) q2=dict(Volume=evidence['Volume']) # del evidence['Speed'] del evidence['Volume'] #fn = TableCPDFactorization(bn)#toolbx #result=fn.condprobve(q1,evidence)#t #mx=max(result.vals) #indx=result.vals.index(mx) #sp= bn.Vdata['Speed']['vals'][indx] fn = TableCPDFactorization(bn)#t result=fn.condprobve(q2,evidence)#t mx=max(result.vals) indx=result.vals.index(mx) vl=bn.Vdata['Volume']['vals'][indx] return [0,vl]
def discrete_query_cb(self, req): nd = U.discrete_nodedata_from_ros(req.nodes) skel = U.graph_skeleton_from_node_data(nd) skel.toporder() bn = DiscreteBayesianNetwork(skel, nd) fn = TableCPDFactorization(bn) q = {n: nd.Vdata[n]["vals"] for n in req.query} ev = {ns.node: ns.state for ns in req.evidence} rospy.loginfo("resolving query %s with evidence %s" % (q, ev)) ans = fn.condprobve(query=q, evidence=ev) rospy.loginfo("%s -> %s" % (ans.scope, ans.vals)) res = DiscreteQueryResponse() node = DiscreteNode() node.name = ans.scope[0] node.outcomes = q[node.name] node.CPT.append(ConditionalProbability(node.outcomes, ans.vals)) res.nodes.append(node) return res
a = TableCPDFactorization(res) #compute the query and evidences as dicts query = dict(Overall=Overall) evidence = dict(Service=Service, Location=Location, Cleanliness=Cleanliness, Value=Value, bad=bad, Rooms=Rooms, old=old, good=good, great=great, comfortable=comfortable) #Checkin=Checkin,Businessservice=Businessservice #run the query given evidence result = a.condprobve(query, evidence) #result2 = a.specificquery(query, evidence) #print(result2) #print json.dumps(result.vals, indent=2) #choose the max probability ditribution as model prediction maxvalue = max(result.vals) pos = GetRealValueLast(result.vals.index(maxvalue)) #append it to our prediction list pred.append(pos + 1) print(count) count = count + 1 #print performances on the performances.csv file with open("performances3.csv", "a") as f: f.write("ACCURACY of the " + str(score) + "th score: " +
class TestTableCPDFactorization(unittest.TestCase): def setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData() nodedata.load("unittestdict.txt") self.bn = DiscreteBayesianNetwork(skel, nodedata) self.fn = TableCPDFactorization(self.bn) def test_constructor(self): self.assertTrue(len(self.fn.originalfactorlist) == 5) for x in range(5): self.assertTrue(isinstance(self.fn.originalfactorlist[x], TableCPDFactor)) def test_refresh(self): evidence = dict(Letter='weak') query = dict(Intelligence=['high']) result1 = self.fn.specificquery(query, evidence) self.fn.refresh() result2 = self.fn.specificquery(query, evidence) self.assertEqual(result1, result2) def test_sumproducteliminatevar(self): self.fn.refresh() self.fn.sumproducteliminatevar("Difficulty") yes = 0 for x in range(len(self.fn.factorlist)): if (self.fn.factorlist[x].scope == ['Grade', 'Intelligence']): yes += 1 index = x self.assertTrue(yes == 1) exp = [0.2, 0.33999999999999997, 0.45999999999999996, 0.74, 0.16799999999999998, 0.09200000000000001] for x in range(6): self.assertTrue(abs(self.fn.factorlist[index].vals[x] - exp[x]) < .01) def test_sumproductve(self): input = ["Difficulty", "Grade", "Intelligence", "SAT"] self.fn.refresh() self.fn.sumproductve(input) exp = [.498, .502] for x in range(2): self.assertTrue(abs(self.fn.factorlist.vals[x] - exp[x]) < .01) def test_condprobve(self): evidence = dict(Grade='C', SAT='highscore') query = dict(Intelligence='high') self.fn.refresh() self.fn.condprobve(query, evidence) exp = [.422, .578] for x in range(2): self.assertTrue(abs(self.fn.factorlist.vals[x] - exp[x]) < .01) def test_specificquery(self): evidence = dict(Difficulty='easy') query = dict(Grade=['A', 'B']) self.fn.refresh() answer = self.fn.specificquery(query, evidence) self.assertTrue(abs(answer - .784) < .01) def test_gibbssample(self): evidence = dict(Letter='weak') gs = self.fn.gibbssample(evidence, 5) self.assertTrue(gs[0]["Difficulty"] == 'easy' or gs[0]["Difficulty"] == 'hard') self.assertTrue(len(gs) == 5) for entry in gs: self.assertTrue(entry["Letter"] == 'weak')
class TestTableCPDFactorization(unittest.TestCase): def setUp(self): skel = GraphSkeleton() skel.load("unittestdict.txt") skel.toporder() nodedata = NodeData() nodedata.load("unittestdict.txt") self.bn = DiscreteBayesianNetwork(skel, nodedata) self.fn = TableCPDFactorization(self.bn) def test_constructor(self): self.assertTrue(len(self.fn.originalfactorlist) == 5) for x in range(5): self.assertTrue(isinstance(self.fn.originalfactorlist[x], TableCPDFactor)) def test_refresh(self): self.fn.refresh() for x in range(5): self.assertTrue(isinstance(self.fn.factorlist[x], TableCPDFactor)) def test_sumproducteliminatevar(self): self.fn.refresh() self.fn.sumproducteliminatevar("Difficulty") yes = 0 for x in range(len(self.fn.factorlist)): if (self.fn.factorlist[x].scope == ['Grade', 'Intelligence']): yes += 1 index = x self.assertTrue(yes == 1) exp = [0.2, 0.33999999999999997, 0.45999999999999996, 0.74, 0.16799999999999998, 0.09200000000000001] for x in range(6): self.assertTrue(abs(self.fn.factorlist[index].vals[x] - exp[x]) < .01) def test_sumproductve(self): input = ["Difficulty", "Grade", "Intelligence", "SAT"] self.fn.refresh() self.fn.sumproductve(input) exp = [.498, .502] for x in range(2): self.assertTrue(abs(self.fn.factorlist.vals[x] - exp[x]) < .01) def test_condprobve(self): evidence = dict(Grade='C', SAT='highscore') query = dict(Intelligence='high') self.fn.refresh() self.fn.condprobve(query, evidence) exp = [.422, .578] for x in range(2): self.assertTrue(abs(self.fn.factorlist.vals[x] - exp[x]) < .01) def test_specificquery(self): evidence = dict(Difficulty='easy') query = dict(Grade=['A', 'B']) self.fn.refresh() answer = self.fn.specificquery(query, evidence) self.assertTrue(abs(answer - .784) < .01) def test_gibbssample(self): evidence = dict(Letter='weak') gs = self.fn.gibbssample(evidence, 5) self.assertTrue(gs[0]["Difficulty"] == 'easy' or gs[0]["Difficulty"] == 'hard') self.assertTrue(len(gs) == 5) for entry in gs: self.assertTrue(entry["Letter"] == 'weak')
# toporder graph skeleton skel.toporder() # load evidence evidence = dict() query = {"Grade":['A']} # load bayesian network bn = DiscreteBayesianNetwork(skel, nd) # load factorization fn = TableCPDFactorization(bn) # calculate probability distribution result = fn.condprobve(query, evidence) # output - toggle comment to see #print json.dumps(result.vals, indent=2) #print json.dumps(result.scope, indent=2) #print json.dumps(result.card, indent=2) #print json.dumps(result.stride, indent=2) # (6) --------------------------------------------------------------------------- # Compute the exact probability of an outcome # load nodedata and graphskeleton nd = NodeData() skel = GraphSkeleton() nd.load("../tests/unittestdict.txt") skel.load("../tests/unittestdict.txt")
'entertainment' 'executive' 'healthcare' 'homemaker' 'lawyer' 'librarian' 'marketing' 'none' 'other' 'programmer' 'retired' 'salesman' 'scientist' 'student' 'technician' 'writer' ] myevidence = dict(gender='F') res2 = [] for occu in occupations: myquery = dict(occupation=[occu]) res2 = tcf.condprobve(query=myquery, evidence=myevidence) #res2=tcf.specificquery(query=myquery,evidence=myevidence) #print res2 print json.dumps(res2.vals, indent=2) mle = res2[0] for i in range(1, len(res2) - 1): mle = max(res2[i - 1], res2[i]) print "mle of occupation given gender is Female" print mle
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