def find_all_prob(): ps = "" with open("prolog/problog_predicates.pl", "r") as f: for line in f: ps += line # Calcolo probabilità tramite problog ps += "query(infect(_))." p = PrologString(ps) dbp = engine.prepare(p) lf = LogicFormula.create_from(p) # ground the program dag = LogicDAG.create_from(lf) # break cycles in the ground program cnf = CNF.create_from(dag) # convert to CNF ddnnf = DDNNF.create_from(cnf) # compile CNF to ddnnf r = ddnnf.evaluate() # Siccome Problog restituisce un dizionario struttrato in questa maniera: # {query(infect(2)): 0.67, query(infect(3)): 0.8, ...} # Bisogna estrarre ogni id dalla chiave nel seguente modo items = [] if len(RedNode.query.all()) > 0: for key, value in r.items(): start = "infect(" end = ")" result = str(key)[len(start):-len(end)] try: u = User.query.get(int(result)) items.append((u, value)) except ValueError: continue return items
def solve(model, semiring, operator): ev = SDD.create_from(model, label_all=True).to_formula( ) if semiring.is_dsp() else LogicDAG.create_from(model, label_all=True) fe = FormulaEvaluatorNSP( ev, semiring) if semiring.is_nsp() else FormulaEvaluator(ev, semiring) weights = ev.extract_weights(semiring=semiring) fe.set_weights(weights) result = {} for n, q in ev.queries(): p = fe.evaluate(q) result[n] = (p, p.integrate(operator)) return result
def call_theorem_prover(theorem_prover, instance_id, question_id, theory, assertion, gold_label, print_log=True): """Function that takes a single theory/assertion example and runs it through the theorem prover to obtain a label. Returns the obtained label, elapsed time to solve it, and exception returned by the engine, if any. """ obtained_result = False millisecs_elapsed = 0 if print_log: print("=======ORIGINAL THEORY=========") theory_as_txt = theory.program(theorem_prover) if print_log: print(theory_as_txt) theory.preprocess(theorem_prover) theory_as_txt = theory.program(theorem_prover) if theorem_prover == "problog": assertion_lf = assertion.logical_form(theorem_prover, False) assertion_lf = f"query({assertion_lf})." program = f"{theory_as_txt}\n{assertion_lf}" if print_log: print("=======PROGRAM FROM PREPROCESSED THEORY=========") print(program) print("=======EXPECTED LABEL=========") print(f" {gold_label}") start_millisecs = current_milli_time() try: lf = LogicFormula.create_from(program) # ground the program dag = LogicDAG.create_from( lf) # break cycles in the ground program sdd = SDD.create_from(dag) result = sdd.evaluate() end_millisecs = current_milli_time() elapsed_millisecs = end_millisecs - start_millisecs result_tuples = [(k, v) for k, v in result.items()] obtained_result = result_tuples[0][1] != float(0) return obtained_result, elapsed_millisecs, None except (NegativeCycle, NonGroundProbabilisticClause, UnknownClause) as e: end_millisecs = current_milli_time() elapsed_millisecs = end_millisecs - start_millisecs if print_log: print( f"!!!Encountered Exception at instance id {instance_id}, question id {question_id}: {e}" ) exception_name = str(type(e)).lstrip("<class '").rstrip("'>") return None, elapsed_millisecs, exception_name return obtained_result, elapsed_millisecs, None
def run_theory_in_problog(theory, assertion): """Run the given theory and assertion through ProbLog engine to obtain a True/False label. If an exception is encountered, return None so that this example will not be part of output.""" theorem_prover = "problog" try: program = theory.program(theorem_prover, assertion) lf = LogicFormula.create_from(program) # ground the program dag = LogicDAG.create_from(lf) # break cycles in the ground program sdd = SDD.create_from(dag) result = sdd.evaluate() result_tuples = [(k, v) for k, v in result.items()] if len(result_tuples) == 0: return False return result_tuples[0][1] != 0.0 except (NegativeCycle, NonGroundProbabilisticClause, UnknownClause) as e: return None return None
def find_user_prob(uid): ps = "" with open("prolog/problog_predicates.pl", "r") as f: for line in f: ps += line # Pulizia dei nodi dinamici date/1 all'interno di problog p = PrologString(ps) dbp = engine.prepare(p) query = Term("clean") res = engine.query(dbp, query) # Calcolo probabilità tramite problog ps += "query(infect(" + str(uid) + "))." p = PrologString(ps) dbp = engine.prepare(p) lf = LogicFormula.create_from(p) # ground the program dag = LogicDAG.create_from(lf) # break cycles in the ground program cnf = CNF.create_from(dag) # convert to CNF ddnnf = DDNNF.create_from(cnf) # compile CNF to ddnnf r = ddnnf.evaluate() # Salvataggio nel database SQLite della data del nodo rosso più vecchio con cui è stato a contatto term = Term("date", None) database = problog_export.database # Database interno di Problog dove vengono salvati i fatti con assertz() node_key = database.find(term) if node_key is not None: node = database.get_node(node_key) dates = node.children.find( term.args) # Tutti i fatti date/1 inseriti con assertz/1 vals = [] if dates: for date in dates: n = database.get_node(date) vals.append(int(n.args[0])) min_val = min(vals) # Trova la data (in millisecondi) minima u = User.query.get(uid) u.oldest_risk_date = min_val db.session.commit() return r
def solve(model, semiring, operator): t = time.time() if semiring.is_dsp(): ev = SDD.create_from(model, label_all=True).to_formula() # for n, q in diagram.queries(): # diagram.get_manager().write_to_dot(diagram.get_inode(q), "examples/formula" + str(q) + ".gv") else: ev = LogicDAG.create_from(model, label_all=True) if semiring.is_nsp(): fe = FormulaEvaluatorNSP(ev, semiring) else: fe = FormulaEvaluator(ev, semiring) weights = ev.extract_weights(semiring=semiring) fe.set_weights(weights) result = {} print("inference time: {}".format(time.time() - t)) for n, q in ev.queries(): p = fe.evaluate(q) result[n] = (p, p.integrate(operator)) return result
def main(): p = PrologString(""" increaseOsteoblasts :- calcium. 0.5::\+increaseOsteoblasts :- calcium, bispho. reduceOsteoclasts :- bispho. 1.0::\+reduceOsteoclasts :- calcium , bispho. osteoprosis :- initialOsteoprosis. 0.85::\+osteoprosis :- reduceOsteoclasts. % Bisphosphonates 0.15::\+osteoprosis :- increaseOsteoblasts. % Calcium % Prior probabilities 0.5::calcium. 0.5::bispho. 0.5::initialOsteoprosis. % Query probability of effect evidence(initialOsteoprosis, true). evidence(calcium, true). evidence(bispho, false). query(osteoprosis). """) #1.3: Create the CNF of the problog lf = LogicFormula.create_from(p,avoid_name_clash=True, keep_order=True, label_all=True) # ground the program print("Ground program") print(LogicFormula.to_prolog(lf)) dag = LogicDAG.create_from(lf,avoid_name_clash=True, keep_order=True, label_all=True) # break cycles in the ground program cnf = CNF.create_from(dag) # convert to CNF print(CNF.to_dimacs(cnf)) ddnnf = DDNNF.create_from(cnf) # compile CNF to ddnnf test = DDNNF.get_weights(ddnnf) print(test) print(ddnnf.evaluate()) #3.1: Create 4 interpretations print("--Create 4 interpretations--") interpretations = create_interpretations(p_without_evidence, 4) for i in interpretations: print(i) #3.2: Create 100, 1000, 10000 interpretations and estimate p_n print("--Estimate parameters--") estimate_parameters(100) estimate_parameters(1000) estimate_parameters(10000)
def solve(model, semiring): t = time.time() if semiring.is_dsp(): ev = SDD.create_from(model, label_all=True).to_formula() print ev print "SDD time: {}".format(time.time() - t) exit(0) else: ev = LogicDAG.create_from(model, label_all=True) if semiring.is_nsp(): fe = FormulaEvaluatorNSP(ev, semiring) else: fe = FormulaEvaluator(ev, semiring) weights = ev.extract_weights(semiring=semiring) # print weights fe.set_weights(weights) result = {} [(n, q)] = ev.queries() p = fe.evaluate(q) result[n] = p return result
person(c). 0.2::stress(X) :- person(X). 0.1::friends(X,Y) :- person(X), person(Y). 0.3::smokes(X) :- stress(X). 0.4::smokes(X) :- friends(X,Y), smokes(Y). evidence(friends(a,b), true). evidence(friends(a,c), true). query(smokes(a)). """) lf2 = LogicFormula.create_from(p2, avoid_name_clash=True, keep_order=True, label_all=True) # print(LogicFormula.to_prolog(lf2)) dag2 = LogicDAG.create_from(lf2, avoid_name_clash=False, keep_order=True, label_all=True) # # print(dag2) # # print(LogicFormula.to_prolog(dag2)) cnf2 = CNF.create_from(dag2) # # print(cnf2.to_dimacs(weighted=True, invert_weights=True)) ddnnf2 = DDNNF.create_from(cnf2) #print(ddnnf2.evaluate()) # # import PyBool_public_interface as Bool # expr = Bool.parse_std("input.txt") # expr = expr["main_expr"] # expr = Bool.exp_cnf(expr) # expr = Bool.simplify(expr) # print(Bool.print_expr(expr))
door_num = range(3, 10) for i in door_num: start = timeit.default_timer() model = m.format(door_num=i) p = PrologString(model) formula = get_evaluatable().create_from(p) print(formula.evaluate()) stop = timeit.default_timer() times.append(stop - start) for i in door_num: model = m.format(door_num=i) p = PrologString(model) lf = LogicFormula.create_from(p) lfs.append(lf) dag = LogicDAG.create_from(lf) dags.append(dag) cnf = CNF.create_from(dag) cnfs.append(cnf) for i in door_num: model = m.format(door_num=i) p = PrologString(model) lf = LogicFormula.create_from(p) lfs.append(lf) dag = LogicDAG.create_from(lf) dags.append(dag) cnf = CNF.create_from(dag) cnfs.append(cnf) ddnnf = DDNNF.create_from(cnf) print(ddnnf.evaluate())
from problog.program import PrologString from problog.formula import LogicFormula, LogicDAG from problog.logic import Term from problog.ddnnf_formula import DDNNF from problog.cnf_formula import CNF p = PrologString(""" coin(c1). coin(c2). 0.4::heads(C); 0.6::tails(C) :- coin(C). win :- heads(C). evidence(heads(c1), false). query(win). query(coin(X)). """) lf = LogicFormula.create_from(p) # ground the program dag = LogicDAG.create_from(lf) # break cycles in the ground program cnf = CNF.create_from(dag) # convert to CNF ddnnf = DDNNF.create_from(cnf) # compile CNF to ddnnf results = ddnnf.evaluate() print(results)
p = PrologString(""" 0.4::heads(1). 0.7::heads(2). 0.5::heads(3). win :- heads(1). win :- heads(2), heads(3). query(win). """) lf = LogicFormula.create_from(p, avoid_name_clash=True, keep_order=True, label_all=True) # ground the program # print(lf) # print(LogicFormula.to_prolog(lf)) dag = LogicDAG.create_from( lf, avoid_name_clash=True, keep_order=True, label_all=True) # break cycles in the ground program # print(dag) # print(LogicFormula.to_prolog(dag)) cnf = CNF.create_from(dag) # convert to CNF # for clause in cnf._clauses: # print(clause) ddnnf = DDNNF.create_from(cnf) # compile CNF to ddnnf # Outcome for the a/b thing with query(a) is 0,2+(0,8*0,3*0,4) # but if evidence(b) : (0,2*0,4+0,2*0,5*0,6+0,4*0,3*0,8) / (0,4+0,6*0,5*0,2) [Formula for conditional probability P(a|b) = ...] # For coin thing : 1-0,6*0,3*0,5-0,6*0,3*0,5-0,6*0,7*0,5 = 0,61 # print(ddnnf.evaluate()) # # ASSIGNMENT #