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 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 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 __init__(
self,
primitives: typing.Sequence,
head_constructor: typing.Union[Predicate, FillerPredicate],
connected_clauses: bool = True,
recursive_procedures: bool = False,
expansion_hooks_keep: typing.Sequence = (),
expansion_hooks_reject: typing.Sequence = ()
) -> None:
self._primitives: typing.Sequence = primitives
self._head_constructor: typing.Union[
Predicate, FillerPredicate
] = head_constructor
# Predicate -> use this predicate in the head
# FillerPredicate -> create new head predicate for each clause/procedure
self._hypothesis_space = None
self._connected_clauses = connected_clauses
self._use_recursions = recursive_procedures
self._recursive_expansion = lambda x: plain_extension(x, self._head_constructor, connected_clauses=True) if (self._use_recursions and isinstance(self._head_constructor, Predicate)) else None
self._pointers: typing.Dict[str, Body] = {"main": None}
self._expansion_hooks_keep = expansion_hooks_keep
self._expansion_hooks_reject = expansion_hooks_reject
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
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")}
task = Task(positive_examples=pos, negative_examples=neg)
# create Prolog instance
prolog = SWIProlog()
learner = SimpleBreadthFirstLearner(prolog, max_body_literals=3)
# create the hypothesis space
hs = TopDownHypothesisSpace(primitives=[
lambda x: plain_extension(x, father, connected_clauses=True),
lambda x: plain_extension(x, mother, connected_clauses=True)
],
head_constructor=grandparent,
expansion_hooks_reject=[
lambda x, y: has_singleton_vars(x, y),
lambda x, y: has_duplicated_literal(x, y)
])
program = learner.learn(task, background, hs)
print(program)
Structure(s, [
List([
Dz, Rz, space, Bz, Ez, Rz, Nz, Az, Rz, Dz, space, Rz, Iz,
Ez, Uz, Xz
]),
List(['d', Rz, space, Rz, 'i', 'e', 'u', 'x'])
])
])
}
# create Prolog instance
prolog = SWIProlog()
# create the hypothesis space
hs = TopDownHypothesisSpace(primitives=[
lambda x: plain_extension(x, not_space, connected_clauses=True),
lambda x: plain_extension(x, mk_uppercase, connected_clauses=True),
lambda x: plain_extension(x, mk_lowercase, connected_clauses=True),
lambda x: plain_extension(x, is_empty, connected_clauses=True),
lambda x: plain_extension(x, is_space, connected_clauses=True),
lambda x: plain_extension(x, is_uppercase, connected_clauses=True),
lambda x: plain_extension(x, not_uppercase, connected_clauses=True),
lambda x: plain_extension(x, is_lowercase, connected_clauses=True),
lambda x: plain_extension(x, not_lowercase, connected_clauses=True),
lambda x: plain_extension(x, is_letter, connected_clauses=True),
lambda x: plain_extension(x, not_letter, connected_clauses=True),
lambda x: plain_extension(x, is_number, connected_clauses=True),
lambda x: plain_extension(x, not_number, connected_clauses=True),
lambda x: plain_extension(x, skip1, connected_clauses=True),
lambda x: plain_extension(x, copy1, connected_clauses=True),
lambda x: plain_extension(x, write1, connected_clauses=True),
# # create the hypothesis space
# hs = TopDownHypothesisSpace(primitives=[lambda x: plain_extension(x, father, connected_clauses=True),
# lambda x: plain_extension(x, mother, connected_clauses=True)],
# head_constructor=grandparent,
# expansion_hooks_reject=[lambda x, y: has_singleton_vars(x, y),
# lambda x, y: has_duplicated_literal(x, y)])
totalextension = []
filtered_predicates = []
for predicate in predicates:
if predicate.name not in ["s", chosen_pred
] and predicate not in filtered_predicates:
totalextension.append(
lambda x, predicate=predicate: plain_extension(
x, predicate, connected_clauses=True))
filtered_predicates.append(predicate)
# create the hypothesis space
hs = TopDownHypothesisSpace(primitives=totalextension,
head_constructor=c_pred("train_task", 1),
expansion_hooks_reject=[
lambda x, y: has_singleton_vars(x, y),
lambda x, y: has_duplicated_literal(x, y)
])
program = learner.learn(task, background, hs)
print(program)