def _run_tests():
from problog.program import PrologString
from problog.engine import DefaultEngine
p = PrologString("""
coin(c1). coin(c2).
0.4::heads(C); 0.6::tails(C) :- coin(C).
win :- heads(C).
""")
engine = DefaultEngine()
db = engine.prepare(p)
# tasks = [
# ([Term("win")], []),
# ([Term("win")], [(Term("heads", Term("c1")), True)]),
# ([Term("win")], [(Term("heads", Term("c1")), False)]),
# ]
# for q,e in tasks:
# qs.prepare_query(q, e)
# print(qs.evaluate_queries())
qs = QuerySession(engine, db)
inline_queries = [" win | heads(c1).", "win | \+heads(c1).", "win."]
for iq in inline_queries:
q, e = qs.transform_inline_query(PrologString(iq)[0])
qs.prepare_query(q, e)
result = qs.evaluate_queries()
print(result)
def load_data(filename, engine=None):
if engine is None:
engine = DefaultEngine()
engine.prepare(PrologString(':- unknown(fail).'))
data = read_data(filename)
background_pl = list(PrologString('\n'.join(data.get('BACKGROUND', []))))
language = CModeLanguage.load(data)
background_pl += language.background
examples = data.get('', [])
examples_db = [
engine.prepare(background_pl + list(PrologString(example_pl)))
for example_pl in examples
]
instances = Interpretations(
[Instance(example_db) for example_db in examples_db], background_pl)
neg_examples = data.get('!', [])
#print("the negative examples are {}".format("".join(neg_examples)))
neg_examples_db = [
engine.prepare(background_pl + list(PrologString(neg_example_pl)))
for neg_example_pl in neg_examples
]
neg_instances = Interpretations(
[Instance(neg_example_db) for neg_example_db in neg_examples_db],
background_pl)
return language, instances, neg_instances, engine
def run_eval_neg(filename, **other):
from .data import read_data, concat, Interpretations, Instance
from problog.program import PrologString
# from problog.logic import AnnotatedDisjunction, Clause
print("starting eval")
data = read_data(filename)
rules = concat(data['RULES'])
engine = DefaultEngine()
engine.prepare(PrologString(':- unknown(fail).'))
background_pl = concat(data.get('BACKGROUND', []))
examples = data.get('!', [])
examples_db = [
engine.prepare(PrologString(background_pl + example_pl))
for example_pl in examples
]
instances = Interpretations(
[Instance(example_db) for example_db in examples_db],
PrologString(background_pl))
for rule in PrologString(rules):
clause = Clause.from_logic(rule)
print('Evaluation of rule:', clause)
if not clause.validate(instances, engine):
print('\tRule is invalid')
#for ex, success in enumerate(clause.successes):
# if not success:
# print('\t\tExample %s:' % (ex + 1), success)
else:
print('\tRule is valid.')
def __init__(self, model_string, networks, caching=False, saving=False):
self.networks = dict()
for network in networks:
self.networks[network.name] = network
network.model = self
self.model_string = self.parse(model_string)
self.engine = problog.engine.DefaultEngine(
), problog.engine.DefaultEngine()
train_model = self.engine[0].prepare(
PrologString(self.model_string[0] + '\n' + self.model_string[1]))
test_model = self.engine[1].prepare(
PrologString(self.model_string[0] + '\n' + self.model_string[2]))
self.problog_model = train_model, test_model
for network in self.networks.values():
network.register_external(*self.problog_model)
self.sdd_manager = None
self.parameters, self.ADs = extract_parameters(train_model)
self.caching = caching
self.saving = saving
self.n = 0
self.obj_store = list()
if caching:
self.sdd_cache = dict()
if saving:
import os
if not os.path.exists('sdd/'):
os.makedirs('sdd/')
def run_ground(model):
"""Ground the program given by model and return an SVG of the resulting formula."""
model = model[0]
knowledge = LogicFormula
#from problog.engine import EngineLogger, SimpleEngineLogger
#EngineLogger.setClass(SimpleEngineLogger)
try:
formula = knowledge.createFrom(PrologString(model))
handle, filename = tempfile.mkstemp('.dot')
with open(filename, 'w') as f:
f.write(formula.toDot())
print(formula)
result = subprocess.check_output(['dot', '-Tsvg',
filename]).decode('utf-8')
content_type = 'application/json'
#EngineLogger.setClass(None)
return 200, content_type, json.dumps({
'svg': result,
'txt': str(formula)
})
except Exception as err:
#EngineLogger.setClass(None)
return process_error(err)
def __init__(self, model_str, probabilistic_data=False, relational_data=False):
# parse the Prolog string
pl_model_sr = PrologString(model_str)
# compile the Prolog model
self.problog_knowledge_sr = get_evaluatable().create_from(pl_model_sr)
self.probabilistic_data = probabilistic_data
self.relational_data = relational_data
def run_test_with_query_instance():
from problog.program import PrologString
from problog.engine import DefaultEngine
from problog.logic import Term, Var
p = PrologString("""
coin(c1). coin(c2).
0.4::heads(C); 0.6::tails(C) :- coin(C).
win :- heads(C).
""")
from .formula_wrapper import FormulaWrapper
s_qs, s_evs = ([Term("win")], [(Term("heads",
Term("c1")), False)]) # For now
engine = DefaultEngine()
probsr = SemiringProbability()
fw = FormulaWrapper(engine.prepare(p))
qobj = AMCQuery(s_qs, s_evs, fw, target_class=DDNNF, semiring=probsr)
qobj.ground(engine)
result, ground_evidence = qobj.evaluate(engine)
print("evidence: ", ground_evidence)
for r in result:
print(r)
print("---")
def main():
p = PrologString("""
mother_child(trude, sally).
father_child(tom, sally).
father_child(tom, erica).
father_child(mike, tom).
sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y).
parent_child(X, Y) :- father_child(X, Y).
parent_child(X, Y) :- mother_child(X, Y).
""")
sibling = Term('sibling')
query_term = sibling(None, None)
engine = DefaultEngine()
# prepare the model for querying
model_db = engine.prepare(p) # This compiles the Prolog model into an internal format.
# This step is optional, but it might be worthwhile if you
# want to query the same model multiple times.
times_query = test_query_method1(engine, model_db, query_term)
times_query_extended = test_query_method2(engine, model_db, query_term)
print("average duration query:", statistics.mean(times_query), "seconds")
print("average duration query:", statistics.mean(times_query_extended), "seconds")
def run_problog(rules, target_rule, target_subject):
model_string = problog_model(rules)
model_string += "query({}(\'{}\',_)).".format(target_rule, target_subject)
print(model_string)
result = get_evaluatable().create_from(
PrologString(model_string)).evaluate()
return result
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 __init__(self,
pos_examples,
neg_examples,
extra_terms=[],
target_name='target'):
# Define the language of terms
self.target = Term(target_name)
self.equal = Term('equal')
self.pos_examples = pos_examples
self.neg_examples = neg_examples
self.examples = pos_examples + neg_examples
self.extra_terms = extra_terms
#TODO: check extra terms arity, if greater than target arity, create more variables
n_target_variables = len(self.examples[0])
target_variables_names = [
'X' + str(i) for i in range(1, n_target_variables + 1)
]
self.X = list(map(Var, target_variables_names))
constants = set()
for example in self.examples:
constants.update(example)
self.c = list(map(Term, [str(constant) for constant in constants]))
# Initialize the logic program
self.pl = SimpleProgram()
self.pl += self.equal(self.X[0], self.X[0])
self.pl += self.target(*tuple(self.X))
for extra_term in self.extra_terms:
self.pl += PrologString(extra_term)
self.predicates = [self.equal] # + list(extra_terms.keys())
self.engine = DefaultEngine()
self.db = self.engine.prepare(self.pl)
self.original_rule = list(self.pl)[1]
self.new_body_literals = []
print(list(self.pl))
def evaluate_custom_weights(self, eval_name=None):
class TestSemiringProbabilityNSP(SemiringProbability):
def is_nsp(self):
return True
program = """
0.25::a.
query(a).
"""
pl = PrologString(program)
lf = LogicFormula.create_from(pl,
label_all=True,
avoid_name_clash=True)
semiring = TestSemiringProbabilityNSP()
kc_class = get_evaluatable(name=eval_name, semiring=semiring)
kc = kc_class.create_from(lf)
a = Term('a')
# without custom weights
results = kc.evaluate(semiring=semiring)
self.assertEqual(0.25, results[a])
# with custom weights
weights = {a: 0.1}
results = kc.evaluate(semiring=semiring, weights=weights)
self.assertEqual(0.1, results[a])
def run_tests_with_static_methods():
from problog.program import PrologString
from problog.engine import DefaultEngine
from problog.logic import Term, Var
p = PrologString("""
coin(c1). coin(c2).
0.4::heads(C); 0.6::tails(C) :- coin(C).
win :- heads(C).
""")
qs, evs = ([Term("win")], [(Term("heads", Term("c1")), False)]) # For now
engine = DefaultEngine()
db = engine.prepare(p)
labels = (LogicFormula.LABEL_QUERY, LogicFormula.LABEL_EVIDENCE_POS,
LogicFormula.LABEL_EVIDENCE_NEG)
lf = LogicFormula()
lf = AMCQuery.ground_query_evidence(engine, db, qs, evs, lf, labels)
circuit = AMCQuery.compile_to_circuit(lf, "ddnnf")
prob_sr = SemiringProbability()
results, ground_evidence = AMCQuery.evaluate_circuit(
circuit, labels, prob_sr)
print("evidence: ", ground_evidence)
for r in results:
print(r)
print("---")
def test_anonymous_variable(self):
"""Anonymous variables are distinct"""
program = """
p(_,X,_) :- X = 3.
q(1,2,3).
q(1,2,4).
q(2,3,5).
r(Y) :- q(_,Y,_).
"""
engine = DefaultEngine()
db = engine.prepare(PrologString(program))
self.assertEqual(
list(
map(
list,
engine.query(
db, Term("p", Constant(1), Constant(3), Constant(2))),
)),
[[Constant(1), Constant(3), Constant(2)]],
)
self.assertEqual(list(map(list, engine.query(db, Term("r", None)))),
[[2], [3]])
def test_cycle_goodcode(self):
N = 20
program = self.program_v1[:]
for i in range(0, N):
seed = str(random.random())[2:]
random.seed(seed)
random.shuffle(program)
txt = "\n".join(program)
f = DefaultEngine(label_all=True).ground_all(PrologString(txt))
paths = list(list_paths(f))
edges = set()
for p in paths:
for i in range(0, len(p) - 1):
edges.add((int(p[i]), int(p[i + 1])))
edges = list(sorted(edges))
# if (edges != self.edges) :
# with open('cycle_error.pl', 'w') as f :
# print(txt, file=f)
# with open('cycle_error.dot', 'w') as f :
# print('digraph CycleError {', file=f)
# for edge in edges :
# print('%s -> %s;' % edge, file=f)
# print('}', file=f)
self.assertCollectionEqual(self.edges,
edges,
msg="Test failed for random seed %s" %
seed)
def run_dtproblog(node_size):
model_text = generate_program(node_size)
print(model_text)
program = PrologString(model_text)
decisions, score, statistics = dtproblog(program)
print("++++++++ Program for node size = "+ str(node_size)+"++++++++")
for name, value in decisions.items():
print ('%s: %s' % (name, value))
def runproblogsampling(s, n=5, output='html'):
model = PrologString(s)
samples = plsample.sample(model, n=n, tuples=True)
result = ''
for sample in samples:
result += ','.join(
str(Term(query[0], *query[1:-1])) for query in sample) + '<br/>'
if output == 'html':
return '<pre>{}</pre>'.format(result)
return result
def main(file):
pl = PrologString(file)
# pl = PrologFile(file)
operator = SumOperator()
result = solve(pl, WmiSemiring(operator.neutral_element), operator)
for k, v in result.items():
(formula, integral) = v
# print('%s(%s): %s\n%s' % (operator, k, integral, formula))
# print(formula.key)
return integral
def test_implementation_predicate(self):
model = (self.module_import + self.load_csv +
"""magic_models:X :-{}(magic_tables,
[column('T1', 2), column('T1', 5)],
[column('T1', 3)],
X).
query(magic_models:{}(_)).
""".format(self.input_predicate, self.output_predicate))
result = get_evaluatable().create_from(PrologString(model)).evaluate()
self.assertEqual(len(result), 1)
def learn_model(fold_i):
fold_n = fold_i + 1
print(f"Learning fold {fold_n} @ {datetime.now()}")
model = get_untrained_model(fold_n)
score, weights, atoms, iteration, lfi_problem = lfi.run_lfi(
PrologString(model), examples=[])
learned_model = lfi_problem.get_model()
with open(pjoin("models", f"model{fold_n}.pl"), "w") as f:
f.write(learned_model + "\n")
def test_compare(self) :
"""Comparison operator"""
program = """
morning(Hour) :- Hour >= 6, Hour =< 10.
"""
engine = DefaultEngine()
db = engine.prepare( PrologString(program) )
self.assertEqual( list(map(list,engine.query(db, Term('morning', Constant(8)) ))), [[8]])
def runproblogsampling(s, n=5, output="html"):
model = PrologString(s)
samples = plsample.sample(model, n=n, tuples=True)
result = ""
for sample in samples:
result += (
",".join(str(Term(query[0], *query[1:-1])) for query in sample) + "<br/>"
)
if output == "html":
return "<pre>{}</pre>".format(result)
return result
def get_timestamps(self):
model = PrologString(self.model + '\n\nquery(allTimeStamps(TPs)).')
knowledge = get_evaluatable().create_from(model)
timestamps = [
term_to_list(term.args[0]) for term in knowledge.evaluate().keys()
if term.functor == 'allTimeStamps'
]
return sorted([item for sublist in timestamps for item in sublist])
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 read_examples(*filenames):
for filename in filenames:
engine = DefaultEngine()
with open(filename) as f:
example = ''
for line in f:
if line.strip().startswith('---'):
pl = PrologString(example)
atoms = extract_evidence(pl)
if len(atoms) > 0:
yield atoms
example = ''
else:
example += line
if example:
pl = PrologString(example)
atoms = extract_evidence(pl)
if len(atoms) > 0:
yield atoms
def evaluate_model(fold_i):
print(f"Testing fold {fold_i} @ {datetime.now()}")
fold_n = fold_i + 1
test = get_text(f"data/5folds-processed/fold{fold_n}", "test_neg.pl")
learned_model = get_text("models", f"model{fold_n}.pl")
pl_model = PrologString(learned_model + "\n" + test)
knowledge = get_evaluatable().create_from(pl_model)
pprint(knowledge.evaluate())
def test_predicates_objects(self):
model = (self.module_import + self.load_csv +
"""magic_models:X :-{}(magic_tables,
[column('T1', 2), column('T1', 5)],
[column('T1', 3)],
X).
same_objects :- magic_models:predictor(T), magic_models:{}(T).
query(same_objects).
""".format(self.input_predicate, self.output_predicate))
result = get_evaluatable().create_from(PrologString(model)).evaluate()
self.assertEqual(len(result), 1)
for term, proba in result.items():
self.assertEqual(proba, 1)
def learn(self):
'''Construisce gli oggetti problog per la valutazione dell'inferenza'''
try:
knowledge_str = ''
for predicate in self.conoscenza_prob:
knowledge_str += predicate + '\n'
knowledge_str = PrologString(knowledge_str)
self.problog = DefaultEngine()
self.knowledge_database = self.problog.prepare(knowledge_str)
except Exception as e:
print(e)
def _run_tests():
def _format_evidence(et):
return "%s%s"%("" if et[1] else "~", et[0])
def _print_result(queries, evidence, query_probs):
print("----")
if e:
print("% Evidence: ", ", ".join(_format_evidence(ev) for ev in e))
print(" . . . ")
print("\n".join(["%s: %f"%(str(k), query_probs[k]) for k in query_probs]))
print("----")
pbl = ProblogWrapper()
p1 = (1, """
0.2::foo(2); 0.3::foo(3); 0.5::foo(5):- bar(Z).
""")
p2 = (None, """
bar(a).
0.7::bar(b).
evidence(\+bar(b)).
query(foo(X)).
""")
for cid, p in [p1, p2]:
q, e = pbl.process_cell(cid, PrologString(p))
res = pbl.query(q,e)
if q:
_print_result(q, e, res)
p1 = (1, """ 0.1::foo(a); 0.25::foo(b); 0.65::foo(c):- bar(Z).""")
for (cid, p) in [p1, p2]:
q ,e = pbl.process_cell(cid, PrologString(p))
res = pbl.query(q,e)
if q:
_print_result(q, e, res)
def test_source_predicate_objects(self):
expected_columns = ["column('T1',5)", "column('T1',3)"]
model = (self.module_import + self.load_csv +
"""magic_models:X :-{}(magic_tables,
[{}],
[column('T1', 2)],
X).
same_objects(C) :- magic_models:source(T, C), magic_models:{}(T).
query(same_objects(C)).
""".format(self.input_predicate, ",".join(expected_columns),
self.output_predicate))
result = get_evaluatable().create_from(PrologString(model)).evaluate()
self.assertEqual(len(result), len(expected_columns))
for term, proba in result.items():
self.assertEqual(proba, 1)
