def equality_test():
term1 = Term(True, 'X_0')
term2 = Term(True, 'X_1')
atom1 = Atom([term1, term1], 'p')
atom2 = Atom([term1, term2], 'p')
head = Atom([term1, term2], 'q')
clause1 = Clause(head, [atom1, atom2])
clause2 = Clause(head, [atom2, atom1])
pred_dict = {}
pred_dict[clause1] = 1
pred_dict[clause2] = 1
assert clause1 == clause2
assert len(pred_dict) == 1
def generate_clauses(self):
'''Generate the clauses based on brute force approach with no optmization
'''
rule_matrix = []
for rule in self.rules:
clauses = []
if (rule.allow_intensional):
p = self.p_e + self.p_a + [self.target]
p_i = self.p_a + [self.target]
intensional_predicates = [atom.predicate for atom in p_i]
else:
p = self.p_e
variables = [
'X_%d' % i for i in range(0, self.target.arity + rule.v)
]
target_variables = [
'X_%d' % i for i in range(0, self.target.arity)
]
# NOTE: Only allows 2 predicates and 2 arity maximum
# TODO: Need for optimizing
for i1 in range(0, len(p)):
for v1 in variables:
for v2 in variables:
for i2 in range(i1, len(p)):
for v3 in variables:
for v4 in variables:
# unsafe
if not set(target_variables).issubset(
[v1, v2, v3, v4]):
continue
head = Atom([
Term(True, var)
for var in target_variables
], self.target.predicate)
body1 = Atom(
[Term(True, v1),
Term(True, v2)], p[i1].predicate)
body2 = Atom(
[Term(True, v3),
Term(True, v4)], p[i2].predicate)
clause = Clause(head, [body1, body2])
if head == body1 or head == body2:
continue
# NOTE: Based on appendix requires to have a intensional predicate
if rule.allow_intensional and not (
body1.predicate
in intensional_predicates
or body2.predicate
in intensional_predicates):
continue
# duplicate
if clause not in clauses:
clauses.append(clause)
print(clauses)
rule_matrix.append(clauses)
return rule_matrix
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 x_c_test():
'''Testing f_c function
'''
term_x = Term(True, 'X_0')
term_y = Term(True, 'X_1')
term_z = Term(True, 'X_2')
r = Atom([term_x, term_y], '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)
def generate_clauses(self):
'''Generate all clauses with some level of optimization
'''
rule_matrix = []
for rule in self.rules:
# logger.info('Generating clauses')
if rule == None:
rule_matrix.append([None])
continue
clauses = []
if (rule.allow_intensional):
p = list(set(self.p_e + self.p_i + [self.target]))
p_i = list(set(self.p_i))
intensional_predicates = [atom.predicate for atom in p_i]
else:
p = list(set(self.p_e))
variables = [
'X_%d' % i for i in range(0, self.target.arity + rule.v)
]
target_variables = [
'X_%d' % i for i in range(0, self.target.arity)
]
# Generate the body list
body_list = []
head = Atom([Term(True, var) for var in target_variables],
self.target.predicate)
for var1 in variables:
for var2 in variables:
term1 = Term(True, var1)
term2 = Term(True, var2)
body_list.append([term1, term2])
# Generate the list
added_pred = {}
for ind1 in range(0, len(p)):
pred1 = p[ind1]
for b1 in body_list:
for ind2 in range(ind1, len(p)):
pred2 = p[ind2]
for b2 in body_list:
body1 = Atom(
[b1[index] for index in range(0, pred1.arity)],
pred1.predicate)
body2 = Atom(
[b2[index] for index in range(0, pred2.arity)],
pred2.predicate)
clause = Clause(head, [body1, body2])
# logger.info(clause)
# All variables in head should be in the body
if not set(target_variables).issubset(
[v.name for v in b1] + [v.name for v in b2]):
continue
elif head == body1 or head == body2: # No Circular
continue
# NOTE: Based on appendix requires to have a intensional predicate
elif rule.allow_intensional and not (
body1.predicate in intensional_predicates
or body2.predicate
in intensional_predicates):
continue
elif clause in added_pred:
continue
else:
added_pred[clause] = 1
clauses.append(clause)
rule_matrix.append(clauses)
# logger.info('Clauses Generated')
return rule_matrix
def generate_clauses(self):
'''Generate all clauses with some level of optimization
'''
rule_matrix = []
for rule in self.rules:
# logger.info('Generating clauses')
if rule is None:
rule_matrix.append([None])
continue
clauses = []
if rule.allow_intensional:
p = list(set(self.p_e + self.p_i + [self.target]))
p_i = list(set(self.p_i))
intensional_predicates = [atom.predicate for atom in p_i]
else:
p = list(set(self.p_e))
variables = ['X_%d' %
i for i in range(0, self.target.arity + rule.v)]
target_variables = ['X_%d' %
i for i in range(0, self.target.arity)]
# Generate the body list
body_list = []
head = Atom(
[Term(True, var) for var in target_variables], self.target.predicate)
for var1 in variables:
for var2 in variables:
term1 = Term(True, var1)
term2 = Term(True, var2)
body_list.append([term1, term2])
# Generate the list
added_pred = {}
for ind1 in range(0, len(p)):
pred1 = p[ind1]
for b1 in body_list:
for ind2 in range(ind1, len(p)):
pred2 = p[ind2]
for b2 in body_list:
for negations in range(4):
if not rule.neg and negations > 0:
continue
body1_atom = Atom([b1[index]
for index in range(0, pred1.arity)], pred1.predicate)
body2_atom = Atom([b2[index]
for index in range(0, pred2.arity)], pred2.predicate)
if negations == 0: # No negation
body1 = Literal(body1_atom, False)
body2 = Literal(body2_atom, False)
if negations == 1: # First body is negated
body1 = Literal(body1_atom, True)
body2 = Literal(body2_atom, False)
if negations == 2: # Second body is negated
body1 = Literal(body1_atom, False)
body2 = Literal(body2_atom, True)
if negations == 3: # Both bodies are negated
body1 = Literal(body1_atom, True)
body2 = Literal(body2_atom, True)
clause = Clause(head, [body1, body2])
# logger.info(clause)
# All variables in head should be in the body
if not set(target_variables).issubset([v.name for v in b1] + [v.name for v in b2]):
continue
elif head == body1 or head == body2: # No Circular
continue
# NOTE: Based on appendix requires to have a intensional predicate
elif rule.allow_intensional and not (body1.predicate in intensional_predicates or body2.predicate in intensional_predicates):
continue
elif clause in added_pred:
continue
# Disallow a clause with the head negated in the body
elif head.predicate == body1.predicate and body1.negated:
continue
elif head.predicate == body2.predicate and body2.negated:
continue
# Disallow positive and negative versions of the same literal in a clause
elif body1_atom == body2_atom and body1.negated != body2.negated:
# If the variables of the clause are different then allow this clause
variables1 = body1_atom.terms
variables2 = body2_atom.terms
add_clause = True
for i in range(len(variables1)):
if variables1[i] != variables2[i]:
add_clause = False
break
if not add_clause:
continue
else:
added_pred[clause] = 1
clauses.append(clause)
rule_matrix.append(clauses)
# logger.info('Clauses Generated')
return rule_matrix
from src.ilp import Language_Frame, Rule_Template, Program_Template
from src.utils import is_intensional
logging.basicConfig(filename="newfile.log",
format='%(asctime)s %(message)s',
filemode='w')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
term1 = Term(True, 'X')
term2 = Term(False, 'USA')
term3 = Term(True, 'Y')
atom1 = Atom([term1, term2], 'PresidentOf')
atom2 = Atom([term1, term2], 'BornIn')
atom3 = Atom([term1, term3], 'BornIn')
clause = Clause(atom1, [atom2])
def core_test():
assert term1.isVariable == True
assert term1.name == 'X'
assert term2.isVariable != True
assert term2.name == 'USA'
assert atom1.predicate == 'PresidentOf'
assert atom1.terms == [term1, term2]
assert atom1.arity == 2
assert clause.head == atom1
assert clause.body == [atom2]
def equality_test():