def new(self,
arity: int = None,
argument_types: Sequence[Type] = None) -> Predicate:
"""
Creates a new predicate from the template
if the FillerPredicate is constructed with arity set, it returns a new predicate with that arity
if the
"""
assert (arity is not None or self._arity is not None
or argument_types is not None)
self._instance_counter += 1
if argument_types is not None:
assert (len(argument_types) == self._arity
or len(argument_types) >= self._min_arity
or len(argument_types) <= self._max_arity)
return c_pred(
f"{self._prefix_name}_{self._instance_counter}",
self._arity,
argument_types,
)
elif arity is not None:
return c_pred(f"{self._prefix_name}_{self._instance_counter}",
arity)
else:
return c_pred(f"{self._prefix_name}_{self._instance_counter}",
self._arity)
def manual_constructs(self):
p1 = c_const("p1")
p2 = c_const("p2")
p3 = c_const("p3")
parent = c_pred("parent", 2)
grandparent = c_pred("grandparent", 2)
f1 = parent(p1, p2)
f2 = parent(p2, p3)
v1 = c_var("X")
v2 = c_var("Y")
v3 = c_var("Z")
cl = grandparent(v1, v3) <= parent(v1, v2) & parent(v2, v3)
assert isinstance(p1, Constant)
assert isinstance(p2, Constant)
assert isinstance(p3, Constant)
assert isinstance(parent, Predicate)
assert isinstance(grandparent, Predicate)
assert isinstance(v1, Variable)
assert isinstance(v2, Variable)
assert isinstance(v2, Variable)
assert isinstance(cl, Clause)
assert isinstance(f1, Atom)
assert isinstance(f2, Atom)
def learn_with_constants():
"""
Consider a row of blocks [ block1 block2 block3 block4 block5 block6 ]
The order of this row is expressed using follows(X,Y)
The color of a block is expressed using color(X,Color)
Goal: learn a function f that says: a block is positive when it is followed by a red block
pos(X) :- next(X,Y), color(Y,red)
"""
block = c_type("block")
col = c_type("col")
block1 = c_const("block1", domain=block) # blue -> positive
block2 = c_const("block2", domain=block) # red
block3 = c_const("block3", domain=block) # green -> positive
block4 = c_const("block4", domain=block) # red -> positive
block5 = c_const("block5", domain=block) # red
block6 = c_const("block6", domain=block) # green
block7 = c_const("block7", domain=block) # blue
block8 = c_const("block8", domain=block) # blue
red = c_const("red", domain="col")
green = c_const("green", domain="col")
blue = c_const("blue", domain="col")
follows = c_pred("follows", 2, domains=[block, block])
color = c_pred("color", 2, domains=[block, col])
# Predicate to learn:
f = c_pred("f", 1, domains=[block])
bk = Knowledge(follows(block1, block2), follows(block2, block3),
follows(block3, block4), follows(block4, block5),
follows(block5, block6), follows(block6, block7),
follows(block7, block8), color(block1, blue),
color(block2, red), color(block3,
green), color(block4, red),
color(block5, red), color(block6, green),
color(block7, blue), color(block8, blue))
pos = {f(x) for x in [block1, block3, block4]}
neg = {f(x) for x in [block2, block5, block6, block7, block8]}
task = Task(positive_examples=pos, negative_examples=neg)
solver = SWIProlog()
# EvalFn must return an upper bound on quality to prune search space.
eval_fn1 = Coverage(return_upperbound=True)
eval_fn2 = Compression(return_upperbound=True)
eval_fn3 = Accuracy(return_upperbound=True)
learners = [
Aleph(solver, eval_fn, max_body_literals=4, do_print=False)
for eval_fn in [eval_fn1, eval_fn3]
]
for learner in learners:
res = learner.learn(task, bk, None, minimum_freq=1)
print(res)
def learn_simpsons():
# define the predicates
father = c_pred("father", 2)
mother = c_pred("mother", 2)
grandparent = c_pred("grandparent", 2)
# specify the background knowledge
background = Knowledge(father("homer", "bart"), father("homer", "lisa"),
father("homer", "maggie"), mother("marge", "bart"),
mother("marge", "lisa"), mother("marge", "maggie"),
mother("mona", "homer"), father("abe", "homer"),
mother("jacqueline", "marge"),
father("clancy", "marge"))
# positive examples
pos = {
grandparent("abe", "bart"),
grandparent("abe", "lisa"),
grandparent("abe", "maggie"),
grandparent("mona", "bart"),
grandparent("abe", "lisa"),
grandparent("abe", "maggie"),
grandparent("jacqueline", "bart"),
grandparent("jacqueline", "lisa"),
grandparent("jacqueline", "maggie"),
grandparent("clancy", "bart"),
grandparent("clancy", "lisa"),
grandparent("clancy", "maggie"),
}
# negative examples
neg = {
grandparent("abe", "marge"),
grandparent("abe", "homer"),
grandparent("abe", "clancy"),
grandparent("abe", "jacqueline"),
grandparent("homer", "marge"),
grandparent("homer", "jacqueline"),
grandparent("jacqueline", "marge"),
grandparent("clancy", "homer"),
grandparent("clancy", "abe")
}
task = Task(positive_examples=pos, negative_examples=neg)
solver = SWIProlog()
# EvalFn must return an upper bound on quality to prune search space.
eval_fn = Coverage(return_upperbound=True)
eval_fn2 = Compression(return_upperbound=True)
eval_fn3 = Compression(return_upperbound=True)
learner = Aleph(solver, eval_fn, max_body_literals=4, do_print=False)
learner2 = Aleph(solver, eval_fn2, max_body_literals=4, do_print=False)
learner3 = Aleph(solver, eval_fn3, max_body_literals=4, do_print=False)
result = learner.learn(task, background, None)
print(result)
def plain_clause_extensions_connected(self):
parent = c_pred("parent", 2)
grandparent = c_pred("grandparent", 2)
cl1 = grandparent("X", "Y") <= parent("X", "Z")
extensions = plain_extension(cl1, parent, connected_clauses=True)
assert len(extensions) == 15
def plain_procedure_extension(self):
parent = c_pred("parent", 2)
ancestor = c_pred("ancestor", 2)
cl1 = ancestor("X", "Y") <= parent("X", "Y")
cl2 = ancestor("X", "Y") <= parent("X", "Z") & parent("Z", "Y")
proc = Disjunction([cl1, cl2])
extensions = plain_extension(proc, parent, connected_clauses=False)
assert len(extensions) == 25
def recursions(self):
parent = c_pred("parent", 2)
ancestor = c_pred("ancestor", 2)
hs = TopDownHypothesisSpace(primitives=[
lambda x: plain_extension(x, parent, connected_clauses=True)
],
head_constructor=ancestor,
recursive_procedures=True)
cls = hs.get_current_candidate()
cls2 = hs.expand(cls[1])
print(cls2)
def _from_body_fixed_arity(
self,
body: Body,
arity: int = None,
arg_types: Sequence[Type] = None,
use_as_head_predicate: Predicate = None,
) -> Sequence[Atom]:
"""
Creates a head atom given the body of the clause
:param body:
:param arity: (optional) desired arity if specified with min/max when constructing the FillerPredicate
:param arg_types: (optional) argument types to use
:return:
"""
assert bool(arity) != bool(arg_types)
vars = body.get_variables()
if use_as_head_predicate and arg_types is None:
arg_types = use_as_head_predicate.get_arg_types()
if arg_types is None:
base = [vars] * arity
else:
matches = {}
for t_ind in range(len(arg_types)):
matches[t_ind] = []
for v_ind in range(len(vars)):
if vars[v_ind].get_type() == arg_types[t_ind]:
matches[t_ind].append(vars[v_ind])
base = [matches[x] for x in range(arity)]
heads = []
for comb in product(*base):
self._instance_counter += 1
if use_as_head_predicate is not None:
pred = use_as_head_predicate
elif arg_types is None:
pred = c_pred(f"{self._prefix_name}_{self._instance_counter}",
arity)
else:
pred = c_pred(
f"{self._prefix_name}_{self._instance_counter}",
len(arg_types),
arg_types,
)
heads.append(Atom(pred, list(comb)))
return heads
def graph_connectivity(self):
v1 = c_const("v1")
v2 = c_const("v2")
v3 = c_const("v3")
v4 = c_const("v4")
edge = c_pred("edge", 2)
path = c_pred("path", 2)
f1 = edge(v1, v2)
f2 = edge(v1, v3)
f3 = edge(v2, v4)
X = c_var("X")
Y = c_var("Y")
Z = c_var("Z")
cl1 = path(X, Y) <= edge(X, Y)
cl2 = path(X, Y) <= path(X, Z) & edge(Z, Y)
solver = MuZ()
solver.assert_fact(f1)
solver.assert_fact(f2)
solver.assert_fact(f3)
solver.assert_rule(cl1)
solver.assert_rule(cl2)
# assert solver.has_solution(path(v1, v2))
# assert solver.has_solution(path(v1, v4))
# assert not solver.has_solution(path(v3, v4))
#
# assert len(solver.one_solution(path(v1, X))) == 1
# assert len(solver.one_solution(path(X, v4))) == 1
# assert len(solver.one_solution(path(X, Y))) == 2
#
# assert len(solver.all_solutions(path(v1, X))) == 3
# assert len(solver.all_solutions(path(X, Y))) == 4
assert solver.has_solution(path(v1, v2))
assert solver.has_solution(path(v1, v4))
assert not solver.has_solution(path(v3, v4))
assert len(solver.query(path(v1, X), max_solutions=1)[0]) == 1
assert len(solver.query(path(X, v4), max_solutions=1)[0]) == 1
assert len(solver.query(path(X, Y), max_solutions=1)[0]) == 2
assert len(solver.query(path(v1, X))) == 3
assert len(solver.query(path(X, Y))) == 4
def shorthand_constructs(self):
parent = c_pred("parent", 2)
grandparent = c_pred("grandparent", 2)
f1 = parent("p1", "p2")
f2 = parent("p2", "p3")
f3 = grandparent("p1", "X")
assert isinstance(parent, Predicate)
assert isinstance(grandparent, Predicate)
assert isinstance(f1, Atom)
assert isinstance(f2, Atom)
assert isinstance(f3, Atom)
assert isinstance(f1.arguments[0], Constant)
assert isinstance(f1.arguments[1], Constant)
assert isinstance(f3.arguments[1], Variable)
def bottom_up(self):
a = c_pred("a", 2)
b = c_pred("b", 2)
c = c_pred("c", 1)
h = c_pred("h", 2)
cl = h("X", "Y") <= a("X", "Z") & b("Z", "Y") & c("X")
bc = BottomClauseExpansion(cl)
hs = TopDownHypothesisSpace(primitives=[lambda x: bc.expand(x)],
head_constructor=h)
cls = hs.get_current_candidate()
assert len(cls) == 3
exps = hs.expand(cls[1])
assert len(exps) == 2
exps2 = hs.expand(exps[0])
assert len(exps2) == 4
def top_down_plain(self):
grandparent = c_pred("grandparent", 2)
father = c_pred("father", 2)
mother = c_pred("mother", 2)
hs = TopDownHypothesisSpace(primitives=[
lambda x: plain_extension(x, father),
lambda x: plain_extension(x, mother)
],
head_constructor=grandparent)
current_cand = hs.get_current_candidate()
assert len(current_cand) == 3
expansions = hs.expand(current_cand[0])
assert len(expansions) == 6
expansions_2 = hs.expand(expansions[0])
assert len(expansions_2) == 10
expansions3 = hs.expand(expansions[1])
assert len(expansions3) == 32
hs.block(expansions[2])
expansions4 = hs.expand(expansions[2])
assert len(expansions4) == 0
hs.remove(expansions[3])
expansions5 = hs.get_successors_of(current_cand[0])
assert len(expansions5) == 5
hs.move_pointer_to(expansions[1])
current_cand = hs.get_current_candidate()
assert current_cand[0] == expansions[1]
hs.ignore(expansions[4])
hs.move_pointer_to(expansions[4])
expansions6 = hs.get_current_candidate()
assert len(expansions6) == 0
def top_down_limited(self):
grandparent = c_pred("grandparent", 2)
father = c_pred("father", 2)
mother = c_pred("mother", 2)
hs = TopDownHypothesisSpace(
primitives=[
lambda x: plain_extension(x, father, connected_clauses=False),
lambda x: plain_extension(x, mother, connected_clauses=False)
],
head_constructor=grandparent,
expansion_hooks_keep=[lambda x, y: connected_clause(x, y)],
expansion_hooks_reject=[lambda x, y: has_singleton_vars(x, y)])
current_cand = hs.get_current_candidate()
assert len(current_cand) == 3
expansions = hs.expand(current_cand[1])
assert len(expansions) == 6
expansion2 = hs.expand(expansions[1])
assert len(expansion2) == 16
def _add_to_body_fixed_arity(self, body: Body,
arity: int) -> Sequence[Body]:
new_pred_stash = {} # arg_types tuple -> pred
vars = body.get_variables()
bodies = []
args = list(combinations(vars, arity))
for ind in range(len(args)):
arg_types = (x.get_type() for x in args[ind])
if arg_types in new_pred_stash:
pred = new_pred_stash[arg_types]
else:
self._instance_counter += 1
pred = c_pred(f"{self._prefix_name}{self._instance_counter}",
arity, arg_types)
new_pred_stash[arg_types] = pred
bodies.append(body + pred(*args[ind]))
return bodies
new_exps = []
for ind in range(len(exps)):
if exps[ind][1]:
# keep it if it has solutions
new_exps.append(exps[ind][0])
else:
# remove from hypothesis space if it does not
hypothesis_space.remove(exps[ind][0])
return new_exps
if __name__ == '__main__':
# define the predicates
father = c_pred("father", 2)
mother = c_pred("mother", 2)
grandparent = c_pred("grandparent", 2)
# specify the background knowledge
background = Knowledge(father("a", "b"), mother("a",
"b"), mother("b", "c"),
father("e", "f"), father("f", "g"),
mother("h", "i"), mother("i", "j"))
# positive examples
pos = {grandparent("a", "c"), grandparent("e", "g"), grandparent("h", "j")}
# negative examples
neg = {grandparent("a", "b"), grandparent("a", "g"), grandparent("i", "j")}
def simple_grandparent(self):
p1 = c_const("p1")
p2 = c_const("p2")
p3 = c_const("p3")
parent = c_pred("parent", 2)
grandparent = c_pred("grandparent", 2)
f1 = parent(p1, p2)
f2 = parent(p2, p3)
v1 = c_var("X")
v2 = c_var("Y")
v3 = c_var("Z")
cl = (grandparent(v1, v3) <= parent(v1, v2) & parent(v2, v3))
solver = MuZ()
solver.assert_fact(f1)
solver.assert_fact(f2)
solver.assert_rule(cl)
# assert solver.has_solution(parent(v1, v2))
# assert not solver.has_solution(parent(v1, v1))
# assert len(solver.all_solutions(parent(v1, v2))) == 2
# assert len(solver.all_solutions(parent(p1, v1))) == 1
# assert solver.has_solution(parent(p1, p2))
# assert not solver.has_solution(parent(p2, p1))
# assert len(solver.one_solution(parent(p1, v1))) == 1
#
# assert solver.has_solution(grandparent(v1, v2))
# assert solver.has_solution(grandparent(p1, v1))
# assert len(solver.one_solution(grandparent(p1, v1))) == 1
# assert solver.has_solution(grandparent(p1, p3))
# assert not solver.has_solution(grandparent(p2, v1))
# assert len(solver.one_solution(grandparent(p1, v1))) == 1
# ans = solver.one_solution(grandparent(p1, v1))
# assert ans[v1] == p3
# ans = solver.one_solution(grandparent(v1, v2))
# assert ans[v1] == p1 and ans[v2] == p3
#
# assert solver.has_solution(cl)
# ans = solver.one_solution(cl)
# assert ans[v1] == p1 and ans[v3] == p3
# assert len(solver.all_solutions(cl)) == 1
assert solver.has_solution(parent(v1, v2))
assert not solver.has_solution(parent(v1, v1))
assert len(solver.query(parent(v1, v2))) == 2
assert len(solver.query(parent(p1, v1))) == 1
assert solver.has_solution(parent(p1, p2))
assert not solver.has_solution(parent(p2, p1))
assert len(solver.query(parent(p1, v1), max_solutions=1)) == 1
assert solver.has_solution(grandparent(v1, v2))
assert solver.has_solution(grandparent(p1, v1))
assert len(solver.query(grandparent(p1, v1), max_solutions=1)) == 1
assert solver.has_solution(grandparent(p1, p3))
assert not solver.has_solution(grandparent(p2, v1))
assert len(solver.query(grandparent(p1, v1), max_solutions=1)) == 1
ans = solver.query(grandparent(p1, v1), max_solutions=1)[0]
assert ans[v1] == p3
ans = solver.query(grandparent(v1, v2), max_solutions=1)[0]
assert ans[v1] == p1 and ans[v2] == p3
assert solver.has_solution(*cl.get_literals())
ans = solver.query(*cl.get_literals(), max_solutions=1)[0]
assert ans[v1] == p1 and ans[v3] == p3
assert len(solver.query(*cl.get_literals())) == 1
def learn_text():
"""
We describe piece of text spanning multiple lines:
"node A red <newline> node B green <newline> node C blue <newline>"
using the next\2, linestart\2, lineend\2, tokenlength\2 predicates
"""
token = c_type("token")
num = c_type("num")
next = c_pred("next", 2, ("token", "token"))
linestart = c_pred("linestart", 2, ("token", "token"))
lineend = c_pred("lineend", 2, ("token", "token"))
tokenlength = c_pred("tokenlength", 2, ("token", "num"))
n1 = c_const("n1", num)
n3 = c_const("n3", num)
n4 = c_const("n4", num)
n5 = c_const("n5", num)
node1 = c_const("node1", token)
node2 = c_const("node2", token)
node3 = c_const("node3", token)
red = c_const("red", token)
green = c_const("green", token)
blue = c_const("blue", token)
a_c = c_const("a_c", token)
b_c = c_const("b_c", token)
c_c = c_const("c_c", token)
start = c_const("c_START", token)
end = c_const("c_END", token)
bk = Knowledge(next(start, node1), next(node1, a_c), next(a_c, red),
next(red, node2), next(node2, green), next(green, b_c),
next(b_c, node3), next(node3, c_c), next(c_c, blue),
next(blue, end), tokenlength(node1, n4),
tokenlength(node2, n4), tokenlength(node3, n4),
tokenlength(a_c, n1), tokenlength(b_c, n1),
tokenlength(c_c, n1), tokenlength(red, n3),
tokenlength(green, n5), tokenlength(blue, n4),
linestart(node1, node1), linestart(a_c, node1),
linestart(red, node1), linestart(node2, node2),
linestart(b_c, node2), linestart(green, node2),
linestart(node3, node3), linestart(c_c, node3),
linestart(blue, node3), lineend(node1, a_c),
lineend(a_c, red), lineend(node2, red), lineend(b_c, green),
lineend(node3, blue), lineend(c_c, blue), lineend(red, red),
lineend(green, green), lineend(blue, blue))
solver = SWIProlog()
eval_fn1 = Coverage(return_upperbound=True)
learner = Aleph(solver, eval_fn1, max_body_literals=3, do_print=False)
# 1. Consider the hypothesis: f1(word) :- word is the second word on a line
if True:
f1 = c_pred("f1", 1, [token])
neg = {f1(x) for x in [node1, node2, node3, blue, green, red]}
pos = {f1(x) for x in [a_c, b_c, c_c]}
task = Task(positive_examples=pos, negative_examples=neg)
res = learner.learn(task, bk, None)
print(res)
# 2. Consider the hypothesis: f2(word) :- word is the first word on a line
if True:
f2 = c_pred("f2", 1, [token])
neg = {f1(x) for x in [a_c, b_c, c_c, blue, green, red]}
pos = {f1(x) for x in [node1, node2, node3]}
task2 = Task(positive_examples=pos, negative_examples=neg)
res = learner.learn(task2, bk, None)
print(res)
# 3. Assume we have learned the predicate node(X) before (A, B and C and nodes).
# We want to learn f3(Node,X) :- X is the next token after Node
if True:
node = c_pred("node", 1, [token])
color = c_pred("color", 1, [token])
nodecolor = c_pred("nodecolor", 2, [token, token])
a = c_var("A", token)
b = c_var("B", token)
bk_old = bk.get_all()
bk = Knowledge(*bk_old, node(a_c), node(b_c), node(c_c), node(a_c),
node(b_c), node(c_c), color(red), color(green),
color(blue))
pos = {
nodecolor(a_c, red),
nodecolor(b_c, green),
nodecolor(c_c, blue)
}
neg = set()
neg = {
nodecolor(node1, red),
nodecolor(node2, red),
nodecolor(node3, red),
nodecolor(node1, blue),
nodecolor(node2, blue),
nodecolor(node2, blue),
nodecolor(node1, green),
nodecolor(node2, green),
nodecolor(node3, green),
nodecolor(a_c, green),
nodecolor(a_c, blue),
nodecolor(b_c, blue),
nodecolor(b_c, red),
nodecolor(c_c, red),
nodecolor(c_c, green)
}
task3 = Task(positive_examples=pos, negative_examples=neg)
# prog = learner.learn(task3,bk,None,initial_clause=Body(node(a),color(b)))
result = learner.learn(task3,
bk,
None,
initial_clause=Body(node(a), color(b)),
minimum_freq=3)
print(result)
if __name__ == '__main__':
chosen_pred = "b45"
backgroundknow, predicates = createKnowledge(
"../inputfiles/StringTransformations_BackgroundKnowledge.pl",
chosen_pred)
train = readPositiveOfType("../inputfiles/StringTransformationProblems",
"train_task")
# print(len(kip))
test = readPositiveOfType("../inputfiles/StringTransformationProblems",
"test_task")
# print(len(kip))
# define the predicates
father = c_pred("father", 2)
mother = c_pred("mother", 2)
grandparent = c_pred("grandparent", 2)
# specify the background knowledge
background = Knowledge(father("a", "b"), mother("a",
"b"), mother("b", "c"),
father("e", "f"), father("f", "g"),
mother("h", "i"), mother("i", "j"))
# # positive examples
# pos = {grandparent("a", "c"), grandparent("e", "g"), grandparent("h", "j")}
#
# # negative examples
# neg = {grandparent("a", "b"), grandparent("a", "g"), grandparent("i", "j")}
#
from loreleai.language.lp import c_functor, c_pred, c_var, List
from loreleai.reasoning.lp.prolog import GNUProlog
pl = GNUProlog()
p = c_pred("p", 2)
f = c_functor("t", 3)
f1 = p("a", "b")
pl.assertz(f1)
X = c_var("X")
Y = c_var("Y")
query = p(X, Y)
r = pl.has_solution(query)
print("has solution", r)
rv = pl.query(query)
print("all solutions", rv)
f2 = p("a", "c")
pl.assertz(f2)
rv = pl.query(query)
print("all solutions after adding f2", rv)
func1 = f(1, 2, 3)
f3 = p(func1, "b")
return newList
if len(var2) == 1:
newList = []
newList.append(list[0].get_predicate()('Y', 'Z', 'U'))
newList.append(list[1].get_predicate()('Y'))
return newList
if len(var2) == 2:
newList = []
newList.append(list[0].get_predicate()('Y', 'Z', 'U'))
newList.append(list[1].get_predicate()('Y', 'Z'))
return newList
if __name__ == '__main__':
# define the predicates
is_empty = c_pred("is_empty", 1)
not_empty = c_pred("not_empty", 1)
is_space = c_pred("is_space", 1)
not_space = c_pred("not_space", 1)
is_uppercase_aux = c_pred("is_uppercase_aux", 1)
is_lowercase_aux = c_pred("is_lowercase_aux", 1)
not_uppercase = c_pred("not_uppercase", 1)
is_lowercase = c_pred("is_lowercase", 1)
not_lowercase = c_pred("not_lowercase", 1)
is_letter = c_pred("is_letter", 1)
not_letter = c_pred("not_letter", 1)
is_number = c_pred("is_number", 1)
not_number = c_pred("not_number", 1)
skip1 = c_pred("skip1", 2)
copy1 = c_pred("copy1", 2)
write1 = c_pred("write1", 3)
def train_task(task_id: string,
pos_multiplier: int,
neg_example_offset: int,
nn_amount: int,
pos=None,
neg=None):
# Load needed files
bk, predicates = createKnowledge(
"../inputfiles/StringTransformations_BackgroundKnowledge.pl", task_id)
if pos is None and neg is None:
pos, neg = generate_examples(task_id, pos_multiplier,
neg_example_offset)
task = Task(positive_examples=pos, negative_examples=neg)
# Calculate predicates
total_predicates = []
filtered_predicates = []
for predicate in predicates:
if predicate.name not in ["s", task_id
] and predicate not in filtered_predicates:
total_predicates.append(lambda x, pred=predicate: plain_extension(
x, pred, connected_clauses=True))
filtered_predicates.append(predicate)
# create the hypothesis space
hs = TopDownHypothesisSpace(
primitives=total_predicates,
head_constructor=c_pred("test_task", 1),
recursive_procedures=True,
expansion_hooks_keep=[
lambda x, y: connected_clause(x, y),
lambda x, y: only_1_pred_for_1_var(x, y),
lambda x, y: head_first(x, y)
],
expansion_hooks_reject=[ # lambda x, y: has_singleton_vars(x, y),
# Singleton-vars constraint is reduced to this constraint
lambda x, y: has_not_previous_output_as_input(x, y), # Strict
# lambda x, y: has_new_input(x, y), # Not as strict
# lambda x, y: has_unexplained_last_var(x, y), # For the 'write' predicate
lambda x, y: has_unexplained_last_var_strict(
x, y), # Strict version of above
lambda x, y: has_duplicated_literal(x, y),
lambda x, y: has_g1_same_vars_in_literal(x, y),
lambda x, y: has_duplicated_var_set(x, y),
lambda x, y: has_double_recursion(x, y),
lambda x, y: has_endless_recursion(x, y)
])
learner = NeuralSearcher1(solver_instance=prolog,
primitives=filtered_predicates,
model_location="../utility/Saved_model_covered",
max_body_literals=10,
amount_chosen_from_nn=nn_amount,
filter_amount=30,
threshold=0.1)
# Try to learn the program
program, ss = learner.learn(
task, "../inputfiles/StringTransformations_BackgroundKnowledge.pl", hs)
print(program)
return ss
from filereaders.taskreader import readPositiveOfType
from loreleai.language.lp import c_pred, c_functor, c_var, List
from loreleai.reasoning.lp.prolog import SWIProlog
# Test for the given background knowledge
pl = SWIProlog()
pl.consult("../inputfiles/StringTransformations_BackgroundKnowledge.pl")
# Load all test tasks in a dictionary. The key is the id of a task and the value is a set of all tasks
test = readPositiveOfType("../inputfiles/StringTransformationProblems",
"test_task")
# Basic variables
test_task = c_pred("test_task", 1)
A = c_var("A")
B = c_var("B")
# one of the examples: test_task(s(['o','x','1',' ','3','c','p'],['O','X','1','3','C','P']))
# Everything in this set starts with lowercase 'o' in the input and uppercase 'O' in output, like the example above
# One example in this set is used to test if it's covered by the clauses below.
tex = test.get("b113").pop()
print(tex)
# We test whether the example starts without a space, this should be true
not_space = c_pred("not_space", 1) # not_space(A):- \+is_space(A).
cl = test_task(A) <= not_space(A)
pl.asserta(cl)
sol = pl.has_solution(tex) # Returns true, good
print(sol)
pl.retract(cl)
