def main_mpe_maxsat(args):
inputfile = args.inputfile
if args.web:
result_handler = print_result_json
else:
result_handler = print_result
if args.output is not None:
outf = open(args.output, 'w')
else:
outf = sys.stdout
with Timer("Total"):
try:
pl = PrologFile(inputfile)
dag = LogicDAG.createFrom(pl,
avoid_name_clash=True,
label_all=True,
labels=[('output', 1)])
prob, output_facts = mpe_maxsat(dag,
verbose=args.verbose,
solver=args.solver)
result_handler((True, (prob, output_facts)), outf)
except Exception as err:
trace = traceback.format_exc()
err.trace = trace
result_handler((False, err), outf)
if args.output is not None:
outf.close()
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 main_mpe_maxsat(args):
inputfile = args.inputfile
if args.web:
result_handler = print_result_json
else:
result_handler = print_result
if args.output is not None:
outf = open(args.output, "w")
else:
outf = sys.stdout
with Timer("Total"):
try:
pl = PrologFile(inputfile)
# filtered_pl = SimpleProgram()
# has_queries = False
# for statement in pl:
# if 'query/1' in statement.predicates:
# has_queries = True
# else:
# filtered_pl += statement
# if has_queries:
# print('%% WARNING: ignoring queries in file', file=sys.stderr)
dag = LogicDAG.createFrom(
pl, avoid_name_clash=True, label_all=True, labels=[("output", 1)]
)
prob, output_facts = mpe_maxsat(
dag, verbose=args.verbose, solver=args.solver, minpe=args.minpe
)
result_handler((True, (prob, output_facts)), outf)
except Exception as err:
trace = traceback.format_exc()
err.trace = trace
result_handler((False, err), outf)
if args.output is not None:
outf.close()
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 main(filename, output):
model = PrologFile(filename)
engine = DefaultEngine(label_all=True)
with Timer("parsing"):
db = engine.prepare(model)
print("\n=== Database ===")
print(db)
print("\n=== Queries ===")
queries = engine.query(db, Term("query", None))
print("Queries:", ", ".join([str(q[0]) for q in queries]))
print("\n=== Evidence ===")
evidence = engine.query(db, Term("evidence", None, None))
print("Evidence:", ", ".join(["%s=%s" % ev for ev in evidence]))
print("\n=== Ground Program ===")
with Timer("ground"):
gp = engine.ground_all(db)
print(gp)
print("\n=== Acyclic Ground Program ===")
with Timer("acyclic"):
gp = LogicDAG.createFrom(gp)
print(gp)
print("\n=== Conversion to CNF ===")
with Timer("convert to CNF"):
cnf = CNF.createFrom(gp)
with open(output, "w") as f:
f.write(cnf.to_dimacs(weighted=False, names=True))
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
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())
def main(filename, with_dot, knowledge):
dotprefix = None
if with_dot:
dotprefix = os.path.splitext(filename)[0] + "_"
model = PrologFile(filename)
engine = DefaultEngine(label_all=True)
with Timer("parsing"):
db = engine.prepare(model)
print("\n=== Database ===")
print(db)
print("\n=== Queries ===")
queries = engine.query(db, Term("query", None))
print("Queries:", ", ".join([str(q[0]) for q in queries]))
print("\n=== Evidence ===")
evidence = engine.query(db, Term("evidence", None, None))
print("Evidence:", ", ".join(["%s=%s" % ev for ev in evidence]))
print("\n=== Ground Program ===")
with Timer("ground"):
gp = engine.ground_all(db)
print(gp)
if dotprefix != None:
with open(dotprefix + "gp.dot", "w") as f:
print(gp.toDot(), file=f)
print("\n=== Acyclic Ground Program ===")
with Timer("acyclic"):
gp = LogicDAG.createFrom(gp)
print(gp)
if dotprefix != None:
with open(dotprefix + "agp.dot", "w") as f:
print(gp.toDot(), file=f)
if knowledge == "sdd":
print("\n=== SDD compilation ===")
with Timer("compile"):
nnf = SDD.createFrom(gp)
if dotprefix != None:
nnf.saveSDDToDot(dotprefix + "sdd.dot")
else:
print("\n=== Conversion to CNF ===")
with Timer("convert to CNF"):
cnf = CNF.createFrom(gp)
print("\n=== Compile to d-DNNF ===")
with Timer("compile"):
nnf = DDNNF.createFrom(cnf)
if dotprefix != None:
with open(dotprefix + "nnf.dot", "w") as f:
print(nnf.toDot(), file=f)
print("\n=== Evaluation result ===")
with Timer("evaluate"):
result = nnf.evaluate()
for it in result.items():
print("%s : %s" % (it))
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)
def compress(formula, atoms):
"""Compress the formula by setting the values of the given atoms."""
# TODO support cyclic programs
formula.clear_labeled("constraint")
out = LogicDAG()
relevant = formula.extract_relevant()
cyclic = set()
translate = {}
for i, n, t in formula:
if not relevant[i]:
continue
elif t == "atom":
if i in atoms:
if atoms[i] == 1:
translate[i] = 0
else:
translate[i] = None
else:
translate[i] = out.add_atom(*n)
else:
children = []
for c in n.children:
if abs(c) in translate:
tr = translate[abs(c)]
if c > 0:
children.append(tr)
else:
children.append(out.negate(tr))
else:
cyclic.add(c)
if t == "conj":
translate[i] = out.add_and(children)
else:
translate[i] = out.add_or(children)
if cyclic:
debug("Original formula:\n", formula)
debug("Cyclic nodes:", cyclic)
debug("New formula so far:\n", out)
raise RuntimeError(
"Cycle detected in program. Cycles are currently not supported.")
for q, n, l in formula.labeled():
if l != "constraint":
if n < 0:
out.add_name(q, out.negate(translate[-n]), l)
else:
out.add_name(q, translate[n], l)
return out
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))
def main(argv, handle_output=None):
args = argparser().parse_args(argv)
verbose = args.verbose
filename = args.filename
if verbose:
debug("Loading...")
problog_model = PrologFile(filename, factory=ConstraintFactory())
engine = DefaultEngine()
database = engine.prepare(problog_model)
# Ground the constraints
if verbose:
debug("Grounding...")
target = engine.ground(database,
Term("constraint", None, None),
label="constraint")
queries = [q[0] for q in engine.query(database, Term("query", None))]
for query in queries:
target = engine.ground(database, query, label="query", target=target)
if verbose > 1:
print(target, file=sys.stderr)
has_prob_constraint = False
for name, index in target.get_names(label="constraint"):
if index is not None:
if name.args[1].functor == "ensure_prob":
has_prob_constraint = True
# Compile and turn into CP-problem
if has_prob_constraint:
if verbose:
debug("Probabilistic constraints detected.")
if verbose:
debug("Compiling...")
sdd = SDD.create_from(target)
formula = sdd.to_formula()
# Convert to flatzinc
if verbose:
debug("Converting...")
fzn = formula_to_flatzinc_float(formula)
sdd.clear_labeled("constraint")
if verbose > 1:
print(fzn, file=sys.stderr)
# Solve the flatzinc model
if verbose:
debug("Solving...")
sols = list(solve(fzn))
has_solution = False
for i, res in enumerate(sols):
if verbose:
debug("Evaluating solution %s/%s..." % (i + 1, len(sols)))
# target.lookup_evidence = {}
weights = sdd.get_weights()
# ev_nodes = []
for k, v in res.items():
sddvar = formula.get_node(k).identifier
sddatom = sdd.var2atom[sddvar]
sddname = sdd.get_name(sddatom)
weights[sddatom] = v
for k, v in sdd.evaluate().items():
if v > 0.0:
print(k, v)
print("----------")
has_solution = True
if has_solution:
print("==========")
else:
print("=== UNSATISFIABLE ===")
else:
formula = LogicDAG()
break_cycles(target, formula)
if verbose:
debug("Converting...")
fzn = formula_to_flatzinc_bool(formula)
if verbose > 1:
print(fzn, file=sys.stderr)
if verbose:
debug("Solving...")
sols = list(solve(fzn))
has_solution = False
for i, res in enumerate(sols):
if verbose:
debug("Evaluating solution %s/%s..." % (i + 1, len(sols)))
if verbose:
debug("Compressing...")
new_formula = compress(formula, res)
if verbose:
debug("Compiling...")
sdd = SDD.create_from(new_formula)
if verbose:
debug("Evaluating...")
for k, v in sdd.evaluate().items():
if v > 0.0:
print(k, v)
print("----------")
has_solution = True
if has_solution:
print("==========")
else:
print("=== UNSATISFIABLE ===")
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
#
