def evaluate_using_problog_library(program, print_steps=False):
""" Evaluates a problog program using the problog library. """
formula = ground_problog_program(program)
if print_steps:
print("GROUND PROGRAM:")
print(formula.to_prolog())
print(separator_1)
cnf = CNF.create_from(formula) # type: CNF
if print_steps:
print("DIMACS:")
print(cnf.to_dimacs(weighted=True, names=True))
print(separator_1)
ddnnf = DDNNF.create_from(cnf)
results = ddnnf.evaluate()
results = sorted(results.items(), key=lambda kv: str(kv[0]))
results = [(str(q), p) for q, p in results]
if print_steps:
print("EVALUATION:")
query_str_len = max([len(q) for q, _ in results])
for query, probability in results:
print("{:<{}}: {}".format(query, query_str_len, probability))
return results
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 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 mpe_maxsat(dag, verbose=0, solver=None):
if dag.queries():
print('%% WARNING: ignoring queries in file', file=sys.stderr)
dag.clear_queries()
logger = init_logger(verbose)
logger.info('Ground program size: %s' % len(dag))
cnf = CNF.createFrom(dag)
for qn, qi in cnf.evidence():
if not cnf.is_true(qi):
cnf.add_constraint(TrueConstraint(qi))
queries = list(cnf.labeled())
logger.info('CNF size: %s' % cnf.clausecount)
if not cnf.is_trivial():
solver = get_solver(solver)
with Timer('Solving'):
result = frozenset(solver.evaluate(cnf))
weights = cnf.extract_weights(SemiringProbability())
output_facts = None
prob = 1.0
if result is not None:
output_facts = []
if queries:
for qn, qi, ql in queries:
if qi in result:
output_facts.append(qn)
elif -qi in result:
output_facts.append(-qn)
for i, n, t in dag:
if t == 'atom':
if i in result:
if not queries:
output_facts.append(n.name)
prob *= weights[i][0]
elif -i in result:
if not queries:
output_facts.append(-n.name)
prob *= weights[i][1]
else:
prob = 1.0
output_facts = []
return prob, output_facts
def mpe_maxsat(dag, verbose=0, solver=None, minpe=False):
logger = init_logger(verbose)
logger.info("Ground program size: %s" % len(dag))
cnf = CNF.createFrom(dag, force_atoms=True)
for qn, qi in cnf.evidence():
if not cnf.is_true(qi):
cnf.add_constraint(TrueConstraint(qi))
queries = list(cnf.labeled())
logger.info("CNF size: %s" % cnf.clausecount)
if not cnf.is_trivial():
solver = get_solver(solver)
with Timer("Solving"):
result = frozenset(solver.evaluate(cnf, invert_weights=minpe))
weights = cnf.extract_weights(SemiringProbability())
output_facts = None
prob = 1.0
if result is not None:
output_facts = []
if queries:
for qn, qi, ql in queries:
if qi in result:
output_facts.append(qn)
elif -qi in result:
output_facts.append(-qn)
for i, n, t in dag:
if t == "atom":
if i in result:
if not queries:
output_facts.append(n.name)
prob *= weights[i][0]
elif -i in result:
if not queries:
output_facts.append(-n.name)
prob *= weights[i][1]
else:
prob = 1.0
output_facts = []
return prob, output_facts
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 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 main(argv, result_handler=None):
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("filename",
metavar="MODEL",
type=str,
help="input ProbLog model")
parser.add_argument(
"--format",
choices=("dot", "pl", "cnf", "svg", "internal"),
default=None,
help="output format",
)
parser.add_argument("--break-cycles",
action="store_true",
help="perform cycle breaking")
parser.add_argument("--transform-nnf",
action="store_true",
help="transform to NNF")
parser.add_argument("--keep-all",
action="store_true",
help="also output deterministic nodes")
parser.add_argument(
"--keep-duplicates",
action="store_true",
help="don't eliminate duplicate literals",
)
parser.add_argument("--any-order",
action="store_true",
help="allow reordering nodes")
parser.add_argument(
"--hide-builtins",
action="store_true",
help="hide deterministic part based on builtins",
)
parser.add_argument("--propagate-evidence",
action="store_true",
help="propagate evidence")
parser.add_argument("--propagate-weights",
action="store_true",
help="propagate evidence")
parser.add_argument(
"--compact",
action="store_true",
help="allow compact model (may remove some predicates)",
)
parser.add_argument("--noninterpretable", action="store_true")
parser.add_argument("--web", action="store_true", help=argparse.SUPPRESS)
parser.add_argument("--verbose",
"-v",
action="count",
default=0,
help="Verbose output")
parser.add_argument("-o",
"--output",
type=str,
help="output file",
default=None)
parser.add_argument(
"-a",
"--arg",
dest="args",
action="append",
help="Pass additional arguments to the cmd_args builtin.",
)
args = parser.parse_args(argv)
outformat = args.format
outfile = sys.stdout
if args.output:
outfile = open(args.output, "w")
if outformat is None:
outformat = os.path.splitext(args.output)[1][1:]
if outformat == "cnf" and not args.break_cycles:
print(
"Warning: CNF output requires cycle-breaking; cycle breaking enabled.",
file=sys.stderr,
)
if args.transform_nnf:
target = LogicNNF
elif args.break_cycles or outformat == "cnf":
target = LogicDAG
else:
target = LogicFormula
if args.propagate_weights:
semiring = SemiringLogProbability()
else:
semiring = None
if args.web:
print_result = print_result_json
else:
print_result = print_result_standard
try:
gp = target.createFrom(
PrologFile(args.filename,
parser=DefaultPrologParser(ExtendedPrologFactory())),
label_all=not args.noninterpretable,
avoid_name_clash=not args.compact,
keep_order=not args.any_order,
keep_all=args.keep_all,
keep_duplicates=args.keep_duplicates,
hide_builtins=args.hide_builtins,
propagate_evidence=args.propagate_evidence,
propagate_weights=semiring,
args=args.args,
)
if outformat == "pl":
rc = print_result((True, gp.to_prolog()), output=outfile)
elif outformat == "dot":
rc = print_result((True, gp.to_dot()), output=outfile)
elif outformat == "svg":
dot = gp.to_dot()
tmpfile = mktempfile(".dot")
with open(tmpfile, "w") as f:
print(dot, file=f)
svg = subprocess_check_output(["dot", tmpfile, "-Tsvg"])
rc = print_result((True, svg), output=outfile)
elif outformat == "cnf":
cnfnames = args.verbose > 0
rc = print_result(
(True, CNF.createFrom(gp).to_dimacs(names=cnfnames)),
output=outfile)
elif outformat == "internal":
rc = print_result((True, str(gp)), output=outfile)
else:
rc = print_result((True, gp.to_prolog()), output=outfile)
except Exception as err:
import traceback
err.trace = traceback.format_exc()
rc = print_result((False, err))
if args.output:
outfile.close()
if rc:
sys.exit(rc)
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))
# Bool.write_dimacs(Bool.cnf_list(expr), "/Users/Bruno/Desktop/dimacs.cnf")
# p3 = PrologString("""
# 0.2::stress(a).
# 0.2::stress(b).
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())
print(times)
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 = gp.makeAcyclic()
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 main(argv, result_handler=None):
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('filename',
metavar='MODEL',
type=str,
help='input ProbLog model')
parser.add_argument('--format',
choices=('dot', 'pl', 'cnf', 'svg', 'internal'),
default=None,
help='output format')
parser.add_argument('--break-cycles',
action='store_true',
help='perform cycle breaking')
parser.add_argument('--transform-nnf',
action='store_true',
help='transform to NNF')
parser.add_argument('--keep-all',
action='store_true',
help='also output deterministic nodes')
parser.add_argument('--keep-duplicates',
action='store_true',
help='don\'t eliminate duplicate literals')
parser.add_argument('--any-order',
action='store_true',
help='allow reordering nodes')
parser.add_argument('--hide-builtins',
action='store_true',
help='hide deterministic part based on builtins')
parser.add_argument('--propagate-evidence',
action='store_true',
help='propagate evidence')
parser.add_argument('--propagate-weights',
action='store_true',
help='propagate evidence')
parser.add_argument(
'--compact',
action='store_true',
help='allow compact model (may remove some predicates)')
parser.add_argument('--noninterpretable', action='store_true')
parser.add_argument('--web', action='store_true', help=argparse.SUPPRESS)
parser.add_argument('--verbose',
'-v',
action='count',
default=0,
help='Verbose output')
parser.add_argument('-o',
'--output',
type=str,
help='output file',
default=None)
parser.add_argument(
'-a',
'--arg',
dest='args',
action='append',
help='Pass additional arguments to the cmd_args builtin.')
args = parser.parse_args(argv)
outformat = args.format
outfile = sys.stdout
if args.output:
outfile = open(args.output, 'w')
if outformat is None:
outformat = os.path.splitext(args.output)[1][1:]
if outformat == 'cnf' and not args.break_cycles:
print(
'Warning: CNF output requires cycle-breaking; cycle breaking enabled.',
file=sys.stderr)
if args.transform_nnf:
target = LogicNNF
elif args.break_cycles or outformat == 'cnf':
target = LogicDAG
else:
target = LogicFormula
if args.propagate_weights:
semiring = SemiringLogProbability()
else:
semiring = None
if args.web:
print_result = print_result_json
else:
print_result = print_result_standard
try:
gp = target.createFrom(PrologFile(args.filename,
parser=DefaultPrologParser(
ExtendedPrologFactory())),
label_all=not args.noninterpretable,
avoid_name_clash=not args.compact,
keep_order=not args.any_order,
keep_all=args.keep_all,
keep_duplicates=args.keep_duplicates,
hide_builtins=args.hide_builtins,
propagate_evidence=args.propagate_evidence,
propagate_weights=semiring,
args=args.args)
if outformat == 'pl':
rc = print_result((True, gp.to_prolog()), output=outfile)
elif outformat == 'dot':
rc = print_result((True, gp.to_dot()), output=outfile)
elif outformat == 'svg':
dot = gp.to_dot()
tmpfile = mktempfile('.dot')
with open(tmpfile, 'w') as f:
print(dot, file=f)
svg = subprocess_check_output(['dot', tmpfile, '-Tsvg'])
rc = print_result((True, svg), output=outfile)
elif outformat == 'cnf':
cnfnames = False
if args.verbose > 0:
cnfnames = True
rc = print_result(
(True, CNF.createFrom(gp).to_dimacs(names=cnfnames)),
output=outfile)
elif outformat == 'internal':
rc = print_result((True, str(gp)), output=outfile)
else:
rc = print_result((True, gp.to_prolog()), output=outfile)
except Exception as err:
import traceback
err.trace = traceback.format_exc()
rc = print_result((False, err))
if args.output:
outfile.close()
if rc:
sys.exit(rc)