def test_target_states(self):
print(">> pylfit.models.DMVLP.target_states()")
for i in range(self._nb_tests):
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm="gula")
values_ids = [[j for j in range(0, len(model.targets[i][1]))]
for i in range(0, len(model.targets))]
expected = [list(i) for i in list(itertools.product(*values_ids))]
output = model.target_states(True)
for state in output:
self.assertTrue(state in expected)
for state in expected:
self.assertTrue(state in output)
values_ids = [[
model.targets[i][1][j]
for j in range(0, len(model.targets[i][1]))
] for i in range(0, len(model.targets))]
expected = [list(i) for i in list(itertools.product(*values_ids))]
output = model.target_states(False)
for state in output:
self.assertTrue(state in expected)
for state in expected:
self.assertTrue(state in output)
def test_copy(self):
print(">> DMVLP.copy()")
features = [("x0", ["0", "1"]), ("x1", ["0", "1"]), ("x2", ["0", "1"])]
targets = [("y0", ["0", "1"]), ("y1", ["0", "1"]), ("y2", ["0", "1"])]
model = DMVLP(features=features, targets=targets)
copy = model.copy()
self.assertEqual(model.features, copy.features)
self.assertEqual(model.targets, copy.targets)
self.assertEqual(model.rules, copy.rules)
self.assertEqual(model.algorithm, copy.algorithm)
for i in range(self._nb_tests):
for algorithm in self._SUPPORTED_ALGORITHMS:
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm=algorithm)
copy = model.copy()
self.assertEqual(model.features, copy.features)
self.assertEqual(model.targets, copy.targets)
self.assertEqual(model.rules, copy.rules)
self.assertEqual(model.algorithm, copy.algorithm)
def test___repr__(self):
print(">> DMVLP.__repr__()")
for i in range(self._nb_tests):
for algorithm in self._SUPPORTED_ALGORITHMS:
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm=algorithm)
self.assertEqual(model.__repr__(), model.to_string())
def test_to_string(self):
print(">> pylfit.models.DMVLP.to_string()")
for i in range(self._nb_tests):
for algorithm in self._SUPPORTED_ALGORITHMS:
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm=algorithm)
expected = \
"{\n"+\
"Algorithm: " + str(model.algorithm)+\
"\nFeatures: "+ str(model.features)+\
"\nTargets: "+ str(model.targets)+\
"\nRules:\n"
for r in model.rules:
expected += r.logic_form(model.features,
model.targets) + "\n"
expected += "}"
self.assertEqual(model.to_string(), expected)
def test_next(self):
print(">> pylfit.semantics.Synchronous.next(feature_state, targets, rules)")
# Unit test
data = [ \
([0,0,0],[0,0,1]), \
([0,0,0],[1,0,0]), \
([1,0,0],[0,0,0]), \
([0,1,0],[1,0,1]), \
([0,0,1],[0,0,1]), \
([1,1,0],[1,0,0]), \
([1,0,1],[0,1,0]), \
([0,1,1],[1,0,1]), \
([1,1,1],[1,1,0])]
feature_names=["p_t-1","q_t-1","r_t-1"]
target_names=["p_t","q_t","r_t"]
dataset = pylfit.preprocessing.transitions_dataset_from_array(data=data, feature_names=feature_names, target_names=target_names)
model = DMVLP(features=dataset.features, targets=dataset.targets)
model.compile(algorithm="gula")
model.fit(dataset=dataset)
feature_state = Algorithm.encode_state([0,0,0], model.features)
self.assertEqual(set([tuple(s) for s in Synchronous.next(feature_state, model.targets, model.rules)]), set([(1,0,0), (0,0,0), (0, 0, 1), (1,0,1)]))
feature_state = Algorithm.encode_state([1,1,1], model.features)
self.assertEqual(set([tuple(s) for s in Synchronous.next(feature_state, model.targets, model.rules)]), set([(1,1,0)]))
feature_state = Algorithm.encode_state([0,1,0], model.features)
self.assertEqual(set([tuple(s) for s in Synchronous.next(feature_state, model.targets, model.rules)]), set([(1,0,1)]))
# incomplete program, semantics with default
model = DMVLP(features=dataset.features, targets=dataset.targets)
rules = [
"p_t(1) :- q_t-1(1)",
"q_t(1) :- p_t-1(1), r_t-1(1)",
"r_t(1) :- p_t-1(0)"]
model.rules = [Rule.from_string(s, model.features, model.targets) for s in rules]
default = [("p_t", [0]), ("q_t", [0]), ("r_t", [0])]
# with default
feature_state = Algorithm.encode_state([1,1,1], model.features)
self.assertEqual(set([tuple(s) for s in Synchronous.next(feature_state, model.targets, model.rules, default)]), set([(1,1,0)]))
# Default to unknow
feature_state = Algorithm.encode_state([1,1,1], model.features)
self.assertEqual(set([tuple(s) for s in Synchronous.next(feature_state, model.targets, model.rules, None)]), set([(1,1,-1)]))
# Random tests
for i in range(self._nb_tests):
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm="pride")
feature_state = random.choice(model.feature_states())
feature_state = Algorithm.encode_state(feature_state, model.features)
output = Synchronous.next(feature_state, model.targets, model.rules, default=None)
domains = [set() for var in model.targets]
# extract conclusion of all matching rules
for r in model.rules:
if(r.matches(feature_state)):
domains[r.head_variable].add(r.head_value)
# Check variables without next value
for i,domain in enumerate(domains):
if len(domain) == 0:
domains[i] = [-1]
# generate all combination of domains
expected = [list(i) for i in list(itertools.product(*domains))]
target_states = output.keys()
expected = [tuple(i) for i in expected]
for s2 in target_states:
self.assertTrue(s2 in expected)
for s2 in expected:
self.assertTrue(s2 in target_states)
for state, rules in output.items():
for r in rules:
self.assertTrue(r.matches(feature_state))
self.assertEqual(r.head_value,state[r.head_variable])
self.assertEqual([],[r for r in model.rules if r not in rules and r.matches(feature_state) and r.head_value == state[r.head_variable]])
def test_summary(self):
print(">> DMVLP.summary()")
for i in range(self._nb_tests):
for algorithm in self._SUPPORTED_ALGORITHMS:
# Empty DMVLP
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm=algorithm)
model.rules = []
expected_print = \
"DMVLP summary:\n"+\
" Algorithm: "+ algorithm +"\n"
expected_print += " Features: \n"
for var, vals in model.features:
expected_print += " " + var + ": " + str(vals) + "\n"
expected_print += " Targets: \n"
for var, vals in model.targets:
expected_print += " " + var + ": " + str(vals) + "\n"
expected_print += " Rules: []\n"
old_stdout = sys.stdout
sys.stdout = mystdout = StringIO()
model.summary()
sys.stdout = old_stdout
self.assertEqual(mystdout.getvalue(), expected_print)
# Usual DMVLP
model = random_DMVLP( \
nb_features=random.randint(1,self._nb_features), \
nb_targets=random.randint(1,self._nb_targets), \
max_feature_values=self._nb_feature_values, \
max_target_values=self._nb_target_values, \
algorithm=algorithm)
expected_print = \
"DMVLP summary:\n"+\
" Algorithm: "+ algorithm +"\n"
expected_print += " Features: \n"
for var, vals in model.features:
expected_print += " " + var + ": " + str(vals) + "\n"
expected_print += " Targets: \n"
for var, vals in model.targets:
expected_print += " " + var + ": " + str(vals) + "\n"
if len(model.rules) == 0:
expected_print += " Rules: []\n"
else:
expected_print += " Rules:\n"
for r in model.rules:
expected_print += " " + r.logic_form(
model.features, model.targets) + "\n"
old_stdout = sys.stdout
sys.stdout = mystdout = StringIO()
model.summary()
sys.stdout = old_stdout
self.assertEqual(mystdout.getvalue(), expected_print)
# Exceptions
#------------
model = DMVLP(features=model.features, targets=model.targets)
self.assertRaises(ValueError,
model.summary) # compile not called