def program_template_test():
rule_template = Rule_Template(1, True)
try:
program_template = Program_Template([atom1],
(rule_template, rule_template),
300)
assert False
except ValueError as err:
assert True
program_template = Program_Template([atom3],
(rule_template, rule_template), 300)
def even_numbers_negation_test():
B_atom = [Atom([Term(False, '0')], 'zero')] + \
[Atom([Term(False, str(i)), Term(False, str(i + 1))], 'succ')
for i in range(0, 20)]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [Atom([Term(False, str(i))], 'target') for i in range(0, 21, 2)]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [Atom([Term(False, str(i))], 'target') for i in range(1, 21, 2)]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [
Literal(Atom([term_x_0], 'zero'), False),
Literal(Atom([term_x_0, term_x_1], 'succ'), False)
]
p_a = [Literal(Atom([term_x_0, term_x_1], 'pred'), False)]
target = Literal(Atom([term_x_0], 'target'), False)
constants = [str(i) for i in range(0, 21)]
# Define rules for intensional predicates
p_a_rule = (Rule_Template_Negation(1, False, False), None)
target_rule = (Rule_Template_Negation(0, False, True),
Rule_Template_Negation(1, True, False))
rules = {p_a[0]: p_a_rule, target: target_rule}
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
#program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(langage_frame, B, P, N, program_template)
return snafdilp.train(steps=300)
def action_sw(bg_all):
#num = 70
#inx=random.sample(range(0,100),num)
#neg_inx = list(set(range(100))-set(inx))
B_0, P_up, P_sw, P_stay, N_up, N_sw, N_stay = get_B_N_P(bg_all)
B = [Atom([Term(False, str(x[1]))], x[0]) for x in B_0]
P = [Atom([Term(False, str(id))], 'sw') for id in P_sw]
N = [Atom([Term(False, str(id))], 'sw') for id in N_sw]
term_x_0 = Term(True, 'X')
term_x_1 = Term(True, 'X1')
p_e = [
Atom([term_x_0], 'busy'),
Atom([term_x_0], 'NObusy'),
Atom([term_x_0], 'side'),
Atom([term_x_0], 'front'),
Atom([term_x_0], 'back')
]
p_a = []
target = Atom([term_x_0], 'sw')
# target_rule = (Rule_Template(0, False), Rule_Template(1, True))
target_rule = (Rule_Template(0, False), None)
rules = {target: target_rule}
constants = [str(i) for i in range(0, 400)]
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
dilp = DILP(langage_frame, B, P, N, program_template)
loss, cl_set = dilp.train(steps=51)
return loss, cl_set
def even_numbers_test():
B = [Atom([Term(False, '0')], 'zero')] + \
[Atom([Term(False, str(i)), Term(False, str(i + 1))], 'succ')
for i in range(0, 20)]
P = [Atom([Term(False, str(i))], 'target') for i in range(0, 21, 2)]
N = [Atom([Term(False, str(i))], 'target') for i in range(1, 21, 2)]
print(P)
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [Atom([term_x_0], 'zero'), Atom([term_x_0, term_x_1], 'succ')]
p_a = [Atom([term_x_0, term_x_1], 'pred')]
target = Atom([term_x_0], 'target')
constants = [str(i) for i in range(0, 21)]
# Define rules for intensional predicates
p_a_rule = (Rule_Template(1, False), None)
target_rule = (Rule_Template(0, False), Rule_Template(1, True))
rules = {p_a[0]: p_a_rule, target: target_rule}
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
#program_template = Program_Template(p_a, rules, 300)
dilp = DILP(langage_frame, B, P, N, program_template)
def generate_ground_atoms_test():
term1 = Term(True, 'X_0')
term2 = Term(True, 'X_1')
target = Atom([term1, term2], 'r')
p_e = [Atom([term1, term2], 'p')]
p_a = [Atom([term1, term2], 'q')]
rule_template_1 = Rule_Template(0, False)
rule_template_2 = Rule_Template(1, True)
language_frame = Language_Frame(target, p_e, set(['a', 'b']))
program_template = Program_Template(p_a,
(rule_template_1, rule_template_2),
300)
term_a = Term(False, 'a')
term_b = Term(False, 'b')
# Background facts: p(a,a) p(a,b)
background = [Atom([term_a, term_a], 'p'), Atom([term_a, term_b], 'p')]
# Positive: p(b,a)
positive = [Atom([term_b, term_a], 'p')]
# Negative: p(b,b)
negative = [Atom([term_b, term_b], 'p')]
ilp = ILP(language_frame, background, positive, negative, program_template)
initial_valuation = ilp.convert()
for valuation in initial_valuation:
if valuation[0] in background:
assert valuation[1] == 1
else:
assert valuation[1] == 0
def action_up_2():
B_0, P_up, P_sw, P_stay, N_up, N_sw, N_stay = get_B_N_P()
B = [Atom([Term(False, str(x[1]))], x[0]) for x in B_0]
N = [Atom([Term(False, str(id))], 'up') for id in P_up]
P = [Atom([Term(False, str(id))], 'up') for id in N_up]
term_x_0 = Term(True, 'X')
term_x_1 = Term(True, 'X1')
p_e = [
Atom([term_x_0], 'busy'),
Atom([term_x_0], 'NObusy'),
Atom([term_x_0], 'side'),
Atom([term_x_0], 'front'),
Atom([term_x_0], 'back')
]
p_a = []
target = Atom([term_x_0], 'up')
# target_rule = (Rule_Template(0, False), Rule_Template(1, True))
target_rule = (Rule_Template(0, False), None)
rules = {target: target_rule}
constants = [str(i) for i in range(0, 400)]
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
dilp = DILP(langage_frame, B, P, N, program_template)
dilp.train(steps=250)
def action_switch_2():
num = 30
inx = random.sample(range(0, 100), num)
neg_inx = list(set(range(100)) - set(inx))
B = [Atom([Term(False, str(id))], 'busy') for id in inx
] + [Atom([Term(False, str(id))], 'NObusy') for id in neg_inx] + [
Atom([Term(False, str(id))], 'front')
for id in neg_inx if id % 2 == 0
] + [
Atom([Term(False, str(id))], 'back')
for id in neg_inx if id % 2 != 0
]
P = [Atom([Term(False, str(id))], 'switch') for id in neg_inx]
N = [Atom([Term(False, str(id))], 'switch') for id in inx]
term_x_0 = Term(True, 'X')
term_x_1 = Term(True, 'X1')
p_e = [
Atom([term_x_0], 'busy'),
Atom([term_x_0], 'NObusy'),
Atom([term_x_0], 'side'),
Atom([term_x_0], 'front'),
Atom([term_x_0], 'back')
]
p_a = []
target = Atom([term_x_0], 'switch')
# target_rule = (Rule_Template(0, False), Rule_Template(1, True))
target_rule = (Rule_Template(0, False), None)
rules = {target: target_rule}
constants = [str(i) for i in range(0, 100)]
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
dilp = DILP(langage_frame, B, P, N, program_template)
dilp.train(steps=252)
def less_than():
B = [Atom([Term(False, '0')], 'zero')] + \
[Atom([Term(False, str(i)), Term(False, str(i + 1))], 'succ')
for i in range(0, 9)]
P = []
N = []
for i in range(0, 10):
for j in range(0, 10):
if j >= i:
N.append(
Atom([Term(False, str(j)), Term(False, str(i))], 'target'))
else:
P.append(
Atom([Term(False, str(j)), Term(False, str(i))], 'target'))
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [Atom([term_x_0], 'zero'), Atom([term_x_0, term_x_1], 'succ')]
p_a = []
target = Atom([term_x_0, term_x_1], 'target')
# target_rule = (Rule_Template(0, False), Rule_Template(1, True))
target_rule = (Rule_Template(0, False), Rule_Template(1, True))
rules = {target: target_rule}
constants = [str(i) for i in range(0, 10)]
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
dilp = DILP(langage_frame, B, P, N, program_template)
dilp.train()
def innocent():
'''
Learn the target predicate of innocent(X)
which is true if X is not guilty
'''
constants = [
'Paul', 'Randy', 'Rachel', 'Bob', 'Alice', 'Stan', 'Kyle', 'Peter',
'Tony', 'Monica'
]
B_atom = [
Atom([Term(False, 'Bob')], 'guilty'),
Atom([Term(False, 'Randy')], 'guilty'),
Atom([Term(False, 'Peter')], 'guilty'),
Atom([Term(False, 'Alice')], 'guilty'),
Atom([Term(False, 'Monica')], 'guilty')
]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'Paul')], 'target'),
Atom([Term(False, 'Rachel')], 'target'),
Atom([Term(False, 'Kyle')], 'target'),
Atom([Term(False, 'Tony')], 'target'),
Atom([Term(False, 'Stan')], 'target')
]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [
Atom([Term(False, 'Bob')], 'target'),
Atom([Term(False, 'Randy')], 'target'),
Atom([Term(False, 'Peter')], 'target'),
Atom([Term(False, 'Alice')], 'target'),
Atom([Term(False, 'Monica')], 'target')
]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
p_e = [Literal(Atom([term_x_0], 'guilty'), False)]
p_a = []
target = Literal(Atom([term_x_0], 'target'), False)
# Define rules for intensional predicates
p_a_rule = (None, None)
target_rule = (Rule_Template_Negation(0, False, True), None)
rules = {target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=200)
def is_cyclic():
'''
Learn the target predicate no_negative_cycle(X). The predicate checks if
a given node in a graph is part of a negative cycle (cycle with at least one
negative edge).
'''
constants = ['a', 'b', 'c', 'd', 'e', 'f']
### (B, P, N) Number 1
B_atom = [
Atom([Term(False, 'a'), Term(False, 'b')], 'edge'),
Atom([Term(False, 'b'), Term(False, 'c')], 'edge'),
Atom([Term(False, 'c'), Term(False, 'a')], 'edge'),
Atom([Term(False, 'b'), Term(False, 'd')], 'edge'),
Atom([Term(False, 'd'), Term(False, 'e')], 'edge'),
Atom([Term(False, 'd'), Term(False, 'f')], 'edge'),
Atom([Term(False, 'f'), Term(False, 'e')], 'edge'),
Atom([Term(False, 'e'), Term(False, 'f')], 'edge')
]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'a')], 'target'),
Atom([Term(False, 'b')], 'target'),
Atom([Term(False, 'c')], 'target'),
Atom([Term(False, 'e')], 'target'),
Atom([Term(False, 'f')], 'target')
]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [Atom([Term(False, 'd')], 'target')]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
term_x_2 = Term(True, 'X_2')
p_e = [Literal(Atom([term_x_0, term_x_1], 'edge'), False)]
p_a = [Literal(Atom([term_x_0, term_x_2], 'pred'), False)]
target = Literal(Atom([term_x_0], 'target'), False)
# Define rules for intensional predicates
p_a_rule = [(Rule_Template_Negation(0, False, False),
Rule_Template_Negation(1, True, False))]
target_rule = (Rule_Template_Negation(0, True, False), None)
rules = {p_a[0]: p_a_rule[0], target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
dilp = DILP(language_frame, B, P, N, program_template)
return dilp.train(steps=300)
def f_c_test2():
'''Testing f_c function
'''
term1 = Term(True, 'X_0')
term2 = Term(True, 'X_1')
target = Atom([term1], 'r')
p_e = [Atom([term1, term2], 'p')]
p_a = [Atom([term1, term2], 'q')]
rule_template_1 = Rule_Template(0, False)
rule_template_2 = Rule_Template(1, True)
language_frame = Language_Frame(target, p_e, set(['a', 'b']))
program_template = Program_Template(p_a,
(rule_template_1, rule_template_2),
300)
term_a = Term(False, 'a')
term_b = Term(False, 'b')
# Background facts: p(a,a) p(a,b)
background = [Atom([term_a, term_a], 'p'), Atom([term_a, term_b], 'p')]
# Positive: p(b,a)
positive = [Atom([term_b, term_a], 'p')]
# Negative: p(b,b)
negative = [Atom([term_b, term_b], 'p')]
ilp = ILP(language_frame, background, positive, negative, program_template)
initial_valuation, valuation_mapping = ilp.convert()
term_x = Term(True, 'X_0')
term_y = Term(True, 'X_1')
term_z = Term(True, 'X_2')
r = Atom([term_x], 'r')
p = Atom([term_x, term_z], 'p')
q = Atom([term_z, term_y], 'q')
clause = Clause(r, [p, q])
# Example from the book
example_val = {
Atom([term_a, term_a], 'p'): 1.0,
Atom([term_a, term_b], 'p'): 0.9,
Atom([term_a, term_a], 'q'): 0.1,
Atom([term_b, term_a], 'q'): 0.2,
Atom([term_b, term_b], 'q'): 0.8,
}
for key in example_val:
initial_valuation[valuation_mapping[key]] = example_val[key]
x_c = Inference.x_c(clause, valuation_mapping, ['a', 'b'])
print(valuation_mapping)
print(x_c)
assert False
def greater_than():
'''
Learn the target predicate greater_than(X,Y) which is true
if X is greater than Y. The aim is to mirror the less_than
predicate use of negation as failure.
'''
constants = [str(i) for i in range(0, 10)]
B_atom = [Atom([Term(False, '0')], 'zero')] + \
[Atom([Term(False, str(i)), Term(False, str(i + 1))], 'succ')
for i in range(0, 9)]
B = [Literal(atom, False) for atom in B_atom]
P_atom = []
N_atom = []
for i in range(0, 10):
for j in range(0, 10):
if j > i:
P_atom.append(
Atom([Term(False, str(j)),
Term(False, str(i))], 'target'))
else:
N_atom.append(
Atom([Term(False, str(j)),
Term(False, str(i))], 'target'))
P = [Literal(atom, False) for atom in P_atom]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [
Literal(Atom([term_x_0], 'zero'), False),
Literal(Atom([term_x_0, term_x_1], 'succ'), False)
]
p_a = [Literal(Atom([term_x_0, term_x_1], 'pred'), False)]
target = Atom([term_x_0, term_x_1], 'target')
# Define rules for intensional predicates
p_a_rule = [(Rule_Template_Negation(0, False, False),
Rule_Template_Negation(1, True, False))]
target_rule = (Rule_Template_Negation(0, True, True), None)
rules = {p_a[0]: p_a_rule[0], target: target_rule}
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
snafdilp = SNAFDILP(langage_frame, B, P, N, program_template)
return snafdilp.train(steps=500)
def odd():
'''
Learn the target predicate of odd(X)
which is true if X is an odd number
'''
B_atom = [Atom([Term(False, '0')], 'zero')] + \
[Atom([Term(False, str(i)), Term(False, str(i + 1))], 'succ')
for i in range(0, 20)]
B = [Literal(atom, False) for atom in B_atom]
# Odd numbers
P_atom = [Atom([Term(False, str(i))], 'target') for i in range(1, 21, 2)]
P = [Literal(atom, False) for atom in P_atom]
# Even numbers
N_atom = [Atom([Term(False, str(i))], 'target') for i in range(0, 21, 2)]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [
Literal(Atom([term_x_0], 'zero'), False),
Literal(Atom([term_x_0, term_x_1], 'succ'), False)
]
p_a = [
Literal(Atom([term_x_0, term_x_1], 'succ2'), False),
Literal(Atom([term_x_0], 'even'), False)
]
target = Literal(Atom([term_x_0], 'target'), False)
constants = [str(i) for i in range(0, 21)]
# Define rules for intensional predicates
succ2_rule = (Rule_Template_Negation(1, False, False), None)
even_rule = (Rule_Template_Negation(0, False, False),
Rule_Template_Negation(1, True, False))
target_rule = (Rule_Template_Negation(0, True, True), None)
rules = {p_a[0]: succ2_rule, p_a[1]: even_rule, target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=400)
def action_switch():
#num = 70
#inx=random.sample(range(0,100),num)
#neg_inx = list(set(range(100))-set(inx))
B_0, P_up, P_sw, P_stay, N_up, N_sw, N_stay = get_B_N_P()
B = [Atom([Term(False, str(x[1]))], x[0]) for x in B_0]
# B = [Atom([Term(False, str(id))], 'busy')
# for id in inx]+ [Atom([Term(False, str(id))], 'NObusy')
# for id in neg_inx]
# print("B..........")
# print(B)
P = [Atom([Term(False, str(id))], 'sw') for id in P_sw]
N = [] #[Atom([Term(False, str(id))], 'sw')
#for id in N_sw]
# print("P..........")
# print(P)
# print("N..........")
# print(N)
term_x_0 = Term(True, 'X')
term_x_1 = Term(True, 'X1')
p_e = [
Atom([term_x_0], 'busy'),
Atom([term_x_0], 'NObusy'),
Atom([term_x_0], 'side'),
Atom([term_x_0], 'front'),
Atom([term_x_0], 'back')
]
#p_a = []
p_a = [Atom([term_x_0], 'pred')]
target = Atom([term_x_0], 'sw')
# target_rule = (Rule_Template(0, False), Rule_Template(1, True))
target_rule = (Rule_Template(0, True), Rule_Template(0, False))
p_a_rule = (Rule_Template(0, False), None)
rules = {p_a[0]: p_a_rule, target: target_rule}
constants = [str(i) for i in range(0, 400)]
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
dilp = DILP(langage_frame, B, P, N, program_template)
dilp.train(steps=252)
def two_children():
'''
Learn the target predicate of has_at_least_two_children(X).
In a directed graph we want to check if a node has at least two children
(that are not equal).
'''
constants = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
edge_relation = [
Atom([Term(False, 'a'), Term(False, 'b')], 'edge'),
Atom([Term(False, 'a'), Term(False, 'c')], 'edge'),
Atom([Term(False, 'b'), Term(False, 'd')], 'edge'),
Atom([Term(False, 'c'), Term(False, 'd')], 'edge'),
Atom([Term(False, 'c'), Term(False, 'e')], 'edge'),
Atom([Term(False, 'd'), Term(False, 'e')], 'edge'),
Atom([Term(False, 'f'), Term(False, 'a')], 'edge'),
Atom([Term(False, 'f'), Term(False, 'b')], 'edge'),
Atom([Term(False, 'g'), Term(False, 'e')], 'edge'),
Atom([Term(False, 'g'), Term(False, 'c')], 'edge')
]
equals_relation = [
Atom([Term(False, x), Term(False, y)], 'equals')
for x, y in zip(constants, constants) if x == y
]
B_atom = edge_relation + equals_relation
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'a')], 'target'),
Atom([Term(False, 'c')], 'target'),
Atom([Term(False, 'f')], 'target'),
Atom([Term(False, 'g')], 'target')
]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [
Atom([Term(False, 'b')], 'target'),
Atom([Term(False, 'd')], 'target'),
Atom([Term(False, 'e')], 'target'),
Atom([Term(False, 'h')], 'target')
]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
term_x_2 = Term(True, 'X_2')
p_e = [
Literal(Atom([term_x_0, term_x_1], 'edge'), False),
Literal(Atom([term_x_0, term_x_1], 'equals'), False)
]
p_a = [Literal(Atom([term_x_0, term_x_2], 'pred'), False)]
target = Literal(Atom([term_x_0], 'target'), False)
# Define rules for intensional predicates
p_a_rule = (Rule_Template_Negation(1, False, True), None)
target_rule = (Rule_Template_Negation(1, True, False), None)
rules = {p_a[0]: p_a_rule, target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=300)
def no_ancestor():
'''
Learn the target predicate of ancestor(X)
which is true if X has no ancestor
'''
constants = [
'Paul', 'Randy', 'Rachel', 'Bob', 'Alice', 'Stan', 'Kyle', 'Peter',
'Tony', 'Monica', 'Jessica', 'Duncan'
]
B_atom = [
Atom([Term(False, 'Bob'), Term(False, 'Paul')], 'parent'),
Atom([Term(False, 'Bob'), Term(False, 'Alice')], 'parent'),
Atom([Term(False, 'Randy'), Term(False, 'Tony')], 'parent'),
Atom([Term(False, 'Randy'), Term(False, 'Stan')], 'parent'),
Atom([Term(False, 'Peter'), Term(False, 'Kyle')], 'parent'),
Atom([Term(False, 'Alice'), Term(False, 'Kyle')], 'parent'),
Atom([Term(False, 'Jessica'),
Term(False, 'Bob')], 'parent'),
Atom([Term(False, 'Jessica'),
Term(False, 'Randy')], 'parent'),
Atom([Term(False, 'Matthew'),
Term(False, 'Jessica')], 'parent')
]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'Peter')], 'target'),
Atom([Term(False, 'Monica')], 'target'),
Atom([Term(False, 'Rachel')], 'target'),
Atom([Term(False, 'Jessica')], 'target'),
Atom([Term(False, 'Duncan')], 'target'),
Atom([Term(False, 'Matthew')], 'target')
]
positive_literal_P = [Literal(atom, False) for atom in P_atom]
N_atom = [
Atom([Term(False, 'Randy')], 'target'),
Atom([Term(False, 'Bob')], 'target'),
Atom([Term(False, 'Alice')], 'target'),
Atom([Term(False, 'Kyle')], 'target'),
Atom([Term(False, 'Tony')], 'target'),
Atom([Term(False, 'Stan')], 'target'),
Atom([Term(False, 'Paul')], 'target')
]
positive_literal_N = [Literal(atom, False) for atom in N_atom]
negative_literal_P = [Literal(atom, True) for atom in N_atom]
negative_literal_N = [Literal(atom, True) for atom in P_atom]
P = positive_literal_P + negative_literal_P
N = positive_literal_N + negative_literal_N
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [Atom([term_x_0, term_x_1], 'parent')]
p_a = []
target = Atom([term_x_0], 'target')
# Define rules for intensional predicates
p_a_rule = (None, None)
target_rule = (Rule_Template_Negation(1, False, True), None)
rules = {target: target_rule}
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
#program_template = Program_Template(p_a, rules, 300)
dilp = DILP(langage_frame, B, P, N, program_template)
dilp.train(steps=200)
from src.core import Term, Atom, Clause
from src.ilp import Language_Frame, Program_Template, Rule_Template, Inference, ILP
epsilon = 0.001
term1 = Term(True, 'X_0')
term2 = Term(True, 'X_1')
target = Atom([term1, term2], 'r')
p_e = [Atom([term1, term2], 'p')]
p_a = [Atom([term1, term2], 'q')]
rule_template_1 = Rule_Template(0, False)
rule_template_2 = Rule_Template(1, True)
language_frame = Language_Frame(target, p_e, set(['a', 'b']))
program_template = Program_Template(p_a, (rule_template_1, rule_template_2),
300)
term_a = Term(False, 'a')
term_b = Term(False, 'b')
# Background facts: p(a,a) p(a,b)
background = [Atom([term_a, term_a], 'p'), Atom([term_a, term_b], 'p')]
# Positive: p(b,a)
positive = [Atom([term_b, term_a], 'p')]
# Negative: p(b,b)
negative = [Atom([term_b, term_b], 'p')]
ilp = ILP(language_frame, background, positive, negative, program_template)
(initial_valuation, valuation_mapping) = ilp.convert()
def x_c_test():
'''Testing f_c function
def not_grandparent():
'''
Learn the target predicate not_grandparent(X,Y) which is true
if X is not the grapndparent of Y.
'''
constants = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
B_atom = [
Atom([Term(False, 'a'), Term(False, 'b')], 'mother'),
Atom([Term(False, 'i'), Term(False, 'a')], 'father'),
Atom([Term(False, 'a'), Term(False, 'b')], 'father'),
Atom([Term(False, 'a'), Term(False, 'c')], 'father'),
Atom([Term(False, 'b'), Term(False, 'd')], 'father'),
Atom([Term(False, 'b'), Term(False, 'e')], 'mother'),
Atom([Term(False, 'c'), Term(False, 'f')], 'mother'),
Atom([Term(False, 'c'), Term(False, 'g')], 'mother'),
Atom([Term(False, 'f'), Term(False, 'h')], 'mother')
]
B = [Literal(atom, False) for atom in B_atom]
N_atom = [
Atom([Term(False, 'i'), Term(False, 'b')], 'target'),
Atom([Term(False, 'i'), Term(False, 'c')], 'target'),
Atom([Term(False, 'a'), Term(False, 'd')], 'target'),
Atom([Term(False, 'a'), Term(False, 'e')], 'target'),
Atom([Term(False, 'a'), Term(False, 'f')], 'target'),
Atom([Term(False, 'a'), Term(False, 'g')], 'target'),
Atom([Term(False, 'c'), Term(False, 'h')], 'target')
]
possible_target_atoms = [
Atom([Term(False, x), Term(False, y)], 'target')
for x, y in itertools.product(constants, constants)
]
P_atom = []
for atom in possible_target_atoms:
if atom not in N_atom:
c1 = atom.terms[0].name
c2 = atom.terms[1].name
P_atom.append(Atom([Term(False, c1), Term(False, c2)], 'target'))
P_atom = random.sample(P_atom, len(N_atom))
P = [Literal(atom, False) for atom in P_atom]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
term_x_2 = Term(True, 'X_2')
p_e = [
Literal(Atom([term_x_0, term_x_1], 'mother'), False),
Literal(Atom([term_x_0, term_x_1], 'father'), False)
]
p_a = [
Literal(Atom([term_x_0, term_x_1], 'pred1'), False),
Literal(Atom([term_x_0, term_x_1], 'pred2'), False)
]
target = Literal(Atom([term_x_0, term_x_2], 'target'), False)
# Define rules for intensional predicates
p_a_rule = [(Rule_Template_Negation(1, True, False), None),
(Rule_Template_Negation(0, False, False),
Rule_Template_Negation(0, False, False))]
target_rule = (Rule_Template_Negation(0, True, True), None)
rules = {p_a[0]: p_a_rule[0], p_a[1]: p_a_rule[1], target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=300)
def orphan():
'''
Learn the target predicate of orphan(X)
which is true if X has no parent
'''
constants = [
'Paul', 'Randy', 'Rachel', 'Bob', 'Alice', 'Steve', 'Frank', 'Julia',
'Stan', 'Kyle', 'Peter', 'Tony', 'Monica', 'Carl', 'Dolores', 'Tommy',
'Pedro', 'Will', 'Sophie', 'Eric', 'Jon', 'Robert', 'Sansa', 'Arya',
'Tormund', 'Mance'
]
# parent(X, Y) is true if X is the father of Y
B_atom = [
Atom([Term(False, 'Bob'), Term(False, 'Paul')], 'parent'),
Atom([Term(False, 'Bob'), Term(False, 'Alice')], 'parent'),
Atom([Term(False, 'Randy'), Term(False, 'Tony')], 'parent'),
Atom([Term(False, 'Randy'), Term(False, 'Stan')], 'parent'),
Atom([Term(False, 'Peter'), Term(False, 'Kyle')], 'parent'),
Atom([Term(False, 'Alice'), Term(False, 'Kyle')], 'parent'),
Atom([Term(False, 'Tony'), Term(False, 'Carl')], 'parent'),
Atom([Term(False, 'Dolores'),
Term(False, 'Tony')], 'parent'),
Atom([Term(False, 'Stan'), Term(False, 'Julia')], 'parent'),
Atom([Term(False, 'Julia'), Term(False, 'Tommy')], 'parent'),
Atom([Term(False, 'Kyle'), Term(False, 'Tommy')], 'parent'),
Atom([Term(False, 'Carl'), Term(False, 'Sophie')], 'parent'),
Atom([Term(False, 'Carl'), Term(False, 'Eric')], 'parent'),
Atom([Term(False, 'Tommy'), Term(False, 'Arya')], 'parent'),
Atom([Term(False, 'Tommy'),
Term(False, 'Tormund')], 'parent'),
Atom([Term(False, 'Tommy'), Term(False, 'Mance')], 'parent')
]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'Randy')], 'target'),
Atom([Term(False, 'Bob')], 'target'),
Atom([Term(False, 'Peter')], 'target'),
Atom([Term(False, 'Rachel')], 'target'),
Atom([Term(False, 'Monica')], 'target'),
Atom([Term(False, 'Dolores')], 'target'),
Atom([Term(False, 'Steve')], 'target'),
Atom([Term(False, 'Frank')], 'target'),
Atom([Term(False, 'Pedro')], 'target'),
Atom([Term(False, 'Will')], 'target'),
Atom([Term(False, 'Jon')], 'target'),
Atom([Term(False, 'Robert')], 'target'),
Atom([Term(False, 'Sansa')], 'target'),
]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [
Atom([Term(False, 'Paul')], 'target'),
Atom([Term(False, 'Alice')], 'target'),
Atom([Term(False, 'Kyle')], 'target'),
Atom([Term(False, 'Tony')], 'target'),
Atom([Term(False, 'Stan')], 'target'),
Atom([Term(False, 'Carl')], 'target'),
Atom([Term(False, 'Julia')], 'target'),
Atom([Term(False, 'Tommy')], 'target'),
Atom([Term(False, 'Sophie')], 'target'),
Atom([Term(False, 'Eric')], 'target'),
Atom([Term(False, 'Arya')], 'target'),
Atom([Term(False, 'Tormund')], 'target'),
Atom([Term(False, 'Mance')], 'target')
]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [Literal(Atom([term_x_0, term_x_1], 'parent'), False)]
p_a = []
target = Literal(Atom([term_x_0], 'target'), False)
# Define rules for intensional predicates
p_a_rule = (None, None)
target_rule = (Rule_Template_Negation(1, False, True), None)
rules = {target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=200)
def can_fly():
'''
Learn the target predicate of can_fly(X)
which is true if X is a bird, but not an abnormal bird
'''
constants = [
'bluebird', 'penguin', 'ostrich', 'blackbird', 'robin', 'sparrow',
'starling', 'chicken', 'kiwi', 'steamerduck', 'kakapo', 'takahe',
'weka', 'pigeon', 'swan', 'duck', 'goldfinch', 'woodpecker', 'bluetit',
'greattit', 'puddle', 'forrestcat', 'pitbull', 'goldenretriever',
'perser', 'bengal', 'siamese', 'sphynx', 'ragdoll', 'savannah',
'sibiriancat', 'greyhound', 'malteser', 'dobermann', 'rottweiler',
'bostonterrier', 'scottishfold', 'exotic', 'russianblue'
]
B_atom = [ # birds
Atom([Term(False, 'bluebird')], 'is_bird'),
Atom([Term(False, 'woodpecker')], 'is_bird'),
Atom([Term(False, 'penguin')], 'is_bird'),
Atom([Term(False, 'bluetit')], 'is_bird'),
Atom([Term(False, 'greattit')], 'is_bird'),
Atom([Term(False, 'ostrich')], 'is_bird'),
Atom([Term(False, 'blackbird')], 'is_bird'),
Atom([Term(False, 'robin')], 'is_bird'),
Atom([Term(False, 'sparrow')], 'is_bird'),
Atom([Term(False, 'starling')], 'is_bird'),
Atom([Term(False, 'chicken')], 'is_bird'),
Atom([Term(False, 'kiwi')], 'is_bird'),
Atom([Term(False, 'steamerduck')], 'is_bird'),
Atom([Term(False, 'kakapo')], 'is_bird'),
Atom([Term(False, 'takahe')], 'is_bird'),
Atom([Term(False, 'weka')], 'is_bird'),
Atom([Term(False, 'pigeon')], 'is_bird'),
Atom([Term(False, 'swan')], 'is_bird'),
Atom([Term(False, 'duck')], 'is_bird'),
Atom([Term(False, 'goldfinch')], 'is_bird'),
# abnormal birds
Atom([Term(False, 'penguin')], 'abnormal_bird'),
Atom([Term(False, 'ostrich')], 'abnormal_bird'),
Atom([Term(False, 'chicken')], 'abnormal_bird'),
Atom([Term(False, 'kiwi')], 'abnormal_bird'),
Atom([Term(False, 'steamerduck')], 'abnormal_bird'),
Atom([Term(False, 'kakapo')], 'abnormal_bird'),
Atom([Term(False, 'takahe')], 'abnormal_bird'),
Atom([Term(False, 'weka')], 'abnormal_bird')
]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'bluebird')], 'target'),
Atom([Term(False, 'blackbird')], 'target'),
Atom([Term(False, 'robin')], 'target'),
Atom([Term(False, 'sparrow')], 'target'),
Atom([Term(False, 'starling')], 'target'),
Atom([Term(False, 'pigeon')], 'target'),
Atom([Term(False, 'swan')], 'target'),
Atom([Term(False, 'duck')], 'target'),
Atom([Term(False, 'goldfinch')], 'target'),
Atom([Term(False, 'woodpecker')], 'target'),
Atom([Term(False, 'bluetit')], 'target'),
Atom([Term(False, 'greattit')], 'target')
]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [
Atom([Term(False, 'penguin')], 'target'),
Atom([Term(False, 'chicken')], 'target'),
Atom([Term(False, 'kiwi')], 'target'),
Atom([Term(False, 'steamerduck')], 'target'),
Atom([Term(False, 'takahe')], 'target'),
Atom([Term(False, 'puddle')], 'target'),
Atom([Term(False, 'siamese')], 'target'),
Atom([Term(False, 'forrestcat')], 'target'),
Atom([Term(False, 'pitbull')], 'target'),
Atom([Term(False, 'sphynx')], 'target'),
Atom([Term(False, 'sibiriancat')], 'target'),
Atom([Term(False, 'greyhound')], 'target'),
Atom([Term(False, 'russianblue')], 'target')
]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
p_e = [
Literal(Atom([term_x_0], 'is_bird'), False),
Literal(Atom([term_x_0], 'abnormal_bird'), False)
]
p_a = []
target = Literal(Atom([term_x_0], 'target'), False)
# Define rules for intensional predicates
p_a_rule = (None, None)
target_rule = (Rule_Template_Negation(0, False, True), None)
rules = {target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=200)
B, pred_f, constants_f = process_file('%s/facts.dilp' % sys.argv[1])
P, target_p, constants_p = process_file('%s/positive.dilp' % sys.argv[1])
N, target_n, constants_n = process_file('%s/negative.dilp' % sys.argv[1])
if not (target_p == target_n):
raise Exception('Positive and Negative files have different targets')
elif not len(target_p) == 1:
raise Exception('Can learn only one predicate at a time')
elif not constants_n.issubset(constants_f) or not constants_p.issubset(
constants_f):
raise Exception(
'Constants not in fact file exists in positive/negative file')
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = list(pred_f)
p_a = [Atom([term_x_0, term_x_1], 'pred')]
target = list(target_p)[0]
constants = constants_f
p_a_rule = (Rule_Template(1, False), None)
target_rule = (Rule_Template(0, False), Rule_Template(1, True))
rules = {p_a[0]: p_a_rule, target: target_rule}
langage_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
dilp = DILP(langage_frame, B, P, N, program_template)
dilp.train()
def has_roommate():
'''
Learn the target predicate of has_roommate(X, Y)
which is true if there exists a person Y that X is married to
and Y is not a researcher.
'''
constants = [
'Paul', 'Randy', 'Rachel', 'Bob', 'Alice', 'Steve', 'Frank', 'Julia',
'Stan', 'Kyle', 'Peter', 'Tony', 'Monica', 'Carl', 'Dolores', 'Tommy',
'Pedro', 'Will', 'Sophie', 'Eric', 'Jon', 'Robert', 'Sansa', 'Arya',
'Tormund', 'Mance'
]
# married(X,Y) with symmetric closure
B_atom = [
Atom([Term(False, 'Bob'), Term(False, 'Rachel')], 'married'),
Atom([Term(False, 'Rachel'), Term(False, 'Bob')], 'married'),
Atom([Term(False, 'Randy'), Term(False, 'Alice')], 'married'),
Atom([Term(False, 'Alice'), Term(False, 'Randy')], 'married'),
Atom([Term(False, 'Steve'), Term(False, 'Julia')], 'married'),
Atom([Term(False, 'Julia'), Term(False, 'Steve')], 'married'),
Atom(
[Term(False, 'Frank'), Term(False, 'Monica')], 'married'),
Atom([Term(False, 'Monica'),
Term(False, 'Frank')], 'married'),
Atom([Term(False, 'Stan'), Term(False, 'Dolores')], 'married'),
Atom([Term(False, 'Dolores'),
Term(False, 'Frank')], 'married'),
Atom([Term(False, 'Will'), Term(False, 'Sophie')], 'married'),
Atom(
[Term(False, 'Sophie'), Term(False, 'Will')], 'married'),
Atom([Term(False, 'Eric'), Term(False, 'Arya')], 'married'),
Atom([Term(False, 'Arya'), Term(False, 'Eric')], 'married'),
# researcher(X)
Atom([Term(False, 'Robert')], 'researcher'),
Atom([Term(False, 'Eric')], 'researcher'),
Atom([Term(False, 'Bob')], 'researcher'),
Atom([Term(False, 'Frank')], 'researcher'),
Atom([Term(False, 'Monica')], 'researcher'),
Atom([Term(False, 'Mance')], 'researcher'),
Atom([Term(False, 'Jon')], 'researcher'),
Atom([Term(False, 'Tormund')], 'researcher'),
Atom([Term(False, 'Sansa')], 'researcher')
]
B = [Literal(atom, False) for atom in B_atom]
P_atom = [
Atom([Term(False, 'Randy')], 'target'),
Atom([Term(False, 'Alice')], 'target'),
Atom([Term(False, 'Steve')], 'target'),
Atom([Term(False, 'Julia')], 'target'),
Atom([Term(False, 'Dolores')], 'target'),
Atom([Term(False, 'Stan')], 'target'),
Atom([Term(False, 'Will')], 'target'),
Atom([Term(False, 'Sophie')], 'target')
]
P = [Literal(atom, False) for atom in P_atom]
N_atom = [
Atom([Term(False, 'Bob')], 'target'),
Atom([Term(False, 'Rachel')], 'target'),
Atom([Term(False, 'Frank')], 'target'),
Atom([Term(False, 'Monica')], 'target'),
Atom([Term(False, 'Kyle')], 'target'),
Atom([Term(False, 'Peter')], 'target'),
Atom([Term(False, 'Tony')], 'target'),
Atom([Term(False, 'Carl')], 'target'),
Atom([Term(False, 'Tommy')], 'target'),
Atom([Term(False, 'Pedro')], 'target'),
Atom([Term(False, 'Tommy')], 'target'),
Atom([Term(False, 'Eric')], 'target'),
Atom([Term(False, 'Arya')], 'target'),
Atom([Term(False, 'Jon')], 'target'),
Atom([Term(False, 'Robert')], 'target'),
Atom([Term(False, 'Mance')], 'target'),
Atom([Term(False, 'Tormund')], 'target')
]
N = [Literal(atom, False) for atom in N_atom]
term_x_0 = Term(True, 'X_0')
term_x_1 = Term(True, 'X_1')
p_e = [
Literal(Atom([term_x_0, term_x_1], 'married'), False),
Literal(Atom([term_x_0], 'researcher'), False)
]
p_a = [Literal(Atom([term_x_0, term_x_1], 'pred'), False)]
target = Literal(Atom([term_x_0], 'target'), False)
# Define rules for intensional predicates
p_a_rule = (Rule_Template_Negation(0, False, True), None)
target_rule = (Rule_Template_Negation(1, True, False), None)
rules = {p_a[0]: p_a_rule, target: target_rule}
language_frame = Language_Frame(target, p_e, constants)
program_template = Program_Template(p_a, rules, 10)
# program_template = Program_Template(p_a, rules, 300)
snafdilp = SNAFDILP(language_frame, B, P, N, program_template)
return snafdilp.train(steps=200)