def test_cross_matches(self): print(">> Rule.cross_matches(self, other)") for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) r_ = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) #eprint(r.to_string()) #eprint(r_.to_string()) if r.cross_matches(r_): for var, val in r.body: if r_.has_condition(var): self.assertEqual(r_.get_condition(var), val) for var, val in r_.body: if r.has_condition(var): self.assertEqual(r.get_condition(var), val) else: exist_difference = False for var, val in r.body: if r_.has_condition(var) and r_.get_condition(var) != val: exist_difference = True break self.assertTrue(exist_difference)
def test_pop_condition(self): print(">> Rule.pop_condition(self)") # Empty rule for i in range(self._nb_tests): var = random.randint(0, self._nb_targets - 1) val = random.randint(0, self._nb_values) r = Rule(var, val, self._nb_features) var = random.randint(0, self._nb_features - 1) r1 = r.copy() r1.pop_condition() self.assertEqual(r, r1) for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) if len(r.body) == 0: i -= 1 continue old_size = r.size() r1 = r.copy() r.pop_condition() self.assertTrue(r.size() == old_size - 1) for var, val in r.body: self.assertTrue(r1.get_condition(var) == val)
def test_remove_condition(self): print(">> Rule.remove_condition(self, variable)") # Empty rule for i in range(self._nb_tests): var = random.randint(0, self._nb_targets - 1) val = random.randint(0, self._nb_values) r = Rule(var, val, self._nb_features) var = random.randint(0, self._nb_features - 1) self.assertFalse(r.has_condition(var)) r.remove_condition(var) self.assertFalse(r.has_condition(var)) for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) if len(r.body) == 0: i -= 1 continue var, val = random.choice(r.body) self.assertTrue(r.has_condition(var)) r.remove_condition(var) self.assertFalse(r.has_condition(var))
def test_get_condition(self): print(">> Rule.get_condition(self, variable)") # Empty rule for i in range(self._nb_tests): var = random.randint(0, self._nb_targets - 1) val = random.randint(0, self._nb_values - 1) r = Rule(var, val, self._nb_features) self.assertEqual( r.get_condition(random.randint(0, self._nb_features - 1)), -1) for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) body = r.body if (len(body) == 0): i -= 1 continue cond = random.randint(0, len(body) - 1) var, val = body[cond] self.assertEqual(r.get_condition(var), val)
def test_size(self): print(">> Rule.size(self)") for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) self.assertEqual(r.size(), len(r.body))
def test_copy(self): print(">> Rule.copy(self)") for i in range(self._nb_tests): r1 = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) r2 = r1.copy() self.assertEqual(r1.head_variable, r2.head_variable) self.assertEqual(r1.head_value, r2.head_value) self.assertEqual(sorted(r1.body), sorted(r2.body))
def test_hamming_distance(self): print(">> pylfit.postprocessing.hamming_distance(rule_1, rule_2)") for i in range(self._nb_random_tests): nb_features = random.randint(1,self._nb_features) nb_targets = random.randint(1,self._nb_targets) nb_values = random.randint(1,self._nb_values) r1 = random_rule(nb_features, nb_targets, nb_values, min(self._max_body_size,nb_features-1)) # Same rule self.assertEqual(hamming_distance(r1,r1), 0) # Modified rule r2 = r1.copy() distance = random.randint(0,r1.size()) for d in range(distance): r2.pop_condition() self.assertEqual(hamming_distance(r1,r2), distance) self.assertEqual(hamming_distance(r2,r1), distance) # Empty rule r1 = random_rule(nb_features, nb_targets, nb_values, 0) r2 = random_rule(nb_features, nb_targets, nb_values, min(self._max_body_size,nb_features-1)) self.assertEqual(hamming_distance(r1,r2), r2.size()) self.assertEqual(hamming_distance(r2,r1), r2.size()) # random rules r1 = random_rule(nb_features, nb_targets, nb_values, min(self._max_body_size,nb_features-1)) r2 = random_rule(nb_features, nb_targets, nb_values, min(self._max_body_size,nb_features-1)) distance = 0 for var in range(nb_features): if r1.get_condition(var) != r2.get_condition(var): distance += 1 self.assertEqual(hamming_distance(r1,r2), distance)
def test_matches(self): print(">> Rule.matches(self, state)") for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) state = [ random.randint(0, self._nb_values) for var in range(self._nb_features + 1) ] body = r.body for var, val in body: state[var] = val self.assertTrue(r.matches(state)) if len(body) == 0: i -= 1 continue state = [ random.randint(0, self._nb_values) for var in range(self._nb_features) ] var, val = random.choice(body) val_ = val while val_ == val: val_ = random.randint(0, self._nb_values) state[var] = val_ self.assertFalse(r.matches(state)) # delay greater than state greater_var_id = 0 for var, val in r.body: greater_var_id = max(greater_var_id, var) state = state[:greater_var_id] self.assertFalse(r.matches(state))
def test_to_string(self): print(">> Rule.to_string(self)") for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) string = str(r.head_variable) + "=" + str(r.head_value) + " :- " for a, b in r.body: string += str(a) + "=" + str(b) + ", " if len(r.body) > 0: string = string[:-2] string += "." self.assertEqual(r.to_string(), string) self.assertEqual(r.to_string(), r.__str__()) self.assertEqual(r.to_string(), r.__repr__())
def test_has_condition(self): print(">> Rule.has_condition(self, variable)") for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) body = r.body for var, val in body: self.assertTrue(r.has_condition(var)) for j in range(10): conditions = [var for var, val in body] var = random.randint(0, self._nb_features - 1) if var in conditions: self.assertTrue(r.has_condition(var)) else: self.assertFalse(r.has_condition(var))
def test_add_condition(self): print(">> Rule.add_condition(self, variable, value)") # Empty rule for i in range(self._nb_tests): var = random.randint(0, self._nb_targets - 1) val = random.randint(0, self._nb_values) r = Rule(var, val, self._nb_features) var = random.randint(0, self._nb_features - 1) val = random.randint(0, self._nb_values) self.assertFalse(r.has_condition(var)) r.add_condition(var, val) self.assertEqual(r.get_condition(var), val) for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) if len(r.body) == 0: i -= 1 continue conditions = [] for var, val in r.body: conditions.append(var) var = conditions[0] while var in conditions: var = random.randint(0, self._nb_features - 1) val = random.randint(0, self._nb_values) self.assertFalse(r.has_condition(var)) r.add_condition(var, val) self.assertEqual(r.get_condition(var), val)
def test_subsumes(self): print(">> Rule.__eq__(self, other)") for i in range(self._nb_tests): r0 = Rule(0, 0, self._nb_features) r1 = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) while r1.size() == 0: r1 = random_rule( self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) r2 = r1.copy() r3 = r1.copy() r4 = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) # r2 is a simplification of r1 if r2.size() > 0: removed = random.randint(1, len(r2.body)) for j in range(0, removed): var = random.choice(r2.body)[0] r2.remove_condition(var) # r3 is a complication of r1 to_add = random.randint(1, self._nb_features - len(r3.body)) while to_add > 0: var = random.randint(0, self._nb_features - 1) val = random.randint(0, self._nb_values) if r3.has_condition(var): continue r3.add_condition(var, val) to_add -= 1 # Self subsumption self.assertTrue(r0.subsumes(r0)) self.assertTrue(r1.subsumes(r1)) self.assertTrue(r2.subsumes(r2)) self.assertTrue(r3.subsumes(r3)) # Empty rule self.assertTrue(r0.subsumes(r1)) self.assertTrue(r0.subsumes(r2)) self.assertEqual(r1.subsumes(r0), len(r1.body) == 0) self.assertEqual(r2.subsumes(r0), len(r2.body) == 0) # Reduction self.assertTrue(r2.subsumes(r1)) self.assertFalse(r1.subsumes(r2)) # Extension self.assertTrue(r1.subsumes(r3)) self.assertFalse(r3.subsumes(r1)) # Random if r1.subsumes(r4): for var, val in r1.body: self.assertEqual(val, r4.get_condition(var)) else: conflicts = 0 for var, val in r1.body: if r4.get_condition(var) != val: conflicts += 1 self.assertTrue(conflicts > 0)
def test___eq__(self): print(">> Rule.__eq__(self, other)") for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) self.assertTrue(r == r) self.assertFalse(r != r) r_ = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) if r.head_variable != r_.head_variable: self.assertFalse(r == r_) if r.head_value != r_.head_value: self.assertFalse(r == r_) if r.body != r_.body: self.assertFalse(r == r_) # different type self.assertFalse(r == "") self.assertFalse(r == 0) self.assertFalse(r == []) self.assertFalse(r == [1, 2, 3]) # different size r_ = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) while r_.size() == r.size(): r_ = random_rule( self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) r_.head_variable = r.head_variable r_.head_value = r.head_value self.assertFalse(r == r_) # Same size, same head while r.size() == 0: r = random_rule( self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) r_ = r.copy() var, val = random.choice(r.body) new_val = val while new_val == val: new_val = random.randint(0, self._nb_values) r_.remove_condition(var) r_.add_condition(var, new_val) self.assertFalse(r == r_) r1 = Rule(r.head_variable, r.head_value, len(r._body_values) + 10, [(len(r._body_values) + 2, 0) for i, j in r.body]) self.assertFalse(r1 == r) self.assertFalse(r == r1)
def test_logic_form(self): print(">> Rule.logic_form(self, features, targets)") # One step rules for i in range(self._nb_tests): r = random_rule(self._nb_features, self._nb_targets, self._nb_values, min(self._max_body_size, self._nb_features - 1)) max_var_id = r.head_variable max_val_id = r.head_value for var, val in r.body: if var > max_var_id: max_var_id = var if val > max_val_id: max_val_id = val features = [("x" + str(var), ["v" + str(val) for val in range(max_val_id + 1)]) for var in range(max_var_id + 1)] targets = [("y" + str(var), ["v" + str(val) for val in range(max_val_id + 1)]) for var in range(max_var_id + 1)] string = targets[r.head_variable][0] + "(" + targets[ r.head_variable][1][r.head_value] + ") :- " for var, val in r.body: string += features[var][0] + "(" + features[var][1][val] + "), " if len(r.body) > 0: string = string[:-2] string += "." self.assertEqual(r.logic_form(features, targets), string) # cosntraints c = random_constraint( len(features), len(targets), max_val_id + 1, min(len(features) + len(targets), self._max_body_size)) #eprint(c.logic_form(features,targets)) string = ":- " for var, val in c.body: if var >= len(features): string += targets[var - len(features)][0] + "(" + targets[ var - len(features)][1][val] + "), " else: string += features[var][0] + "(" + features[var][1][ val] + "), " if len(c.body) > 0: string = string[:-2] string += "." self.assertEqual(c.logic_form(features, targets), string) # exceptions self.assertRaises(ValueError, r.logic_form, features, []) self.assertRaises(ValueError, r.logic_form, features, [(i, []) for i, j in targets]) r1 = r.copy() r1.add_condition(-1, 0) self.assertRaises(ValueError, r1.logic_form, features, targets) self.assertRaises(ValueError, r.logic_form, features, []) if r.size() > 0: self.assertRaises(ValueError, r.logic_form, [], targets) if c.size() > 0: self.assertRaises(ValueError, c.logic_form, [], [])