def _check_rules_and_predictions(self, dataset, expected_string_rules,
expected_string_constraints):
expected_string_rules = [
s.strip() for s in expected_string_rules.strip().split("\n")
if len(s) > 0
]
expected_string_constraints = [
s.strip() for s in expected_string_constraints.strip().split("\n")
if len(s) > 0
]
expected_rules = []
for string_rule in expected_string_rules:
expected_rules.append(
Rule.from_string(string_rule, dataset.features,
dataset.targets))
expected_constraints = []
for string_constraint in expected_string_constraints:
expected_constraints.append(
Rule.from_string(string_constraint, dataset.features,
dataset.targets))
#eprint(expected_rules)
rules, constraints = Synchronizer.fit(dataset)
#eprint(output)
for r in expected_rules:
if r not in rules:
eprint("Missing rule: ", r)
self.assertTrue(r in rules)
for r in rules:
if r not in expected_rules:
eprint("Additional rule: ", r)
self.assertTrue(r in expected_rules)
for r in expected_constraints:
if r not in constraints:
eprint("Missing constraint: ", r)
self.assertTrue(r in constraints)
for r in constraints:
if r not in expected_constraints:
eprint("Additional constraint: ", r)
self.assertTrue(r in constraints)
model = CDMVLP(dataset.features, dataset.targets, rules, constraints)
#model.compile("synchronizer")
#model.summary()
expected = set((tuple(s1), tuple(s2)) for s1, s2 in dataset.data)
predicted = model.predict(model.feature_states())
predicted = set(
(tuple(s1), tuple(s2)) for (s1, S2) in predicted for s2 in S2)
eprint()
done = 0
for s1, s2 in expected:
done += 1
eprint("\rChecking transitions ", done, "/", len(expected), end='')
self.assertTrue((s1, s2) in predicted)
done = 0
for s1, s2 in predicted:
done += 1
eprint("\rChecking transitions ",
done,
"/",
len(predicted),
end='')
self.assertTrue((s1, s2) in expected)
def test_predict(self):
print(">> CDMVLP.predict()")
for i in range(self._nb_tests):
dataset = random_StateTransitionsDataset( \
nb_transitions=random.randint(1, self._nb_transitions), \
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)
for algorithm in self._SUPPORTED_ALGORITHMS:
model = CDMVLP(features=dataset.features,
targets=dataset.targets)
model.compile(algorithm=algorithm)
model.fit(dataset=dataset)
feature_states = list(set(
tuple(s1) for s1, s2 in dataset.data))
prediction = model.predict(feature_states)
for state_id, s1 in enumerate(feature_states):
feature_state_encoded = []
for var_id, val in enumerate(s1):
val_id = model.features[var_id][1].index(str(val))
feature_state_encoded.append(val_id)
#eprint(feature_state_encoded)
target_states = SynchronousConstrained.next(
feature_state_encoded, model.targets, model.rules,
model.constraints)
output = []
for s in target_states:
target_state = []
for var_id, val_id in enumerate(s):
#eprint(var_id, val_id)
if val_id == -1:
target_state.append("?")
else:
target_state.append(
model.targets[var_id][1][val_id])
output.append(target_state)
self.assertEqual(prediction[state_id][0], list(s1))
self.assertEqual(prediction[state_id][1], output)
# Force missing value
model.rules = [
r for r in model.rules if
r.head_variable != random.randint(0, len(model.targets))
]
prediction = model.predict(feature_states)
for state_id, s1 in enumerate(feature_states):
feature_state_encoded = []
for var_id, val in enumerate(s1):
val_id = model.features[var_id][1].index(str(val))
feature_state_encoded.append(val_id)
#eprint(feature_state_encoded)
target_states = SynchronousConstrained.next(
feature_state_encoded, model.targets, model.rules,
model.constraints)
output = []
for s in target_states:
target_state = []
for var_id, val_id in enumerate(s):
#eprint(var_id, val_id)
if val_id == -1:
target_state.append("?")
else:
target_state.append(
model.targets[var_id][1][val_id])
output.append(target_state)
self.assertEqual(prediction[state_id][1], output)
# Exceptions:
self.assertRaises(
TypeError, model.predict,
"") # Feature_states bad format: is not a list
self.assertRaises(
TypeError, model.predict,
[["0", "1"], 0, 10
]) # Feature_states bad format: is not a list of list
self.assertRaises(
TypeError, model.predict, [["0", "1"], [0, 10]]
) # Feature_states bad format: is not a list of list of string
feature_states = [
list(s) for s in set(tuple(s1) for s1, s2 in dataset.data)
]
state_id = random.randint(0, len(feature_states) - 1)
original = feature_states[state_id].copy()
feature_states[state_id] = feature_states[
state_id][:-random.randint(1, len(dataset.features))]
self.assertRaises(
TypeError, model.predict, feature_states
) # Feature_states bad format: size of state not correspond to model features <
feature_states[state_id] = original.copy()
feature_states[state_id].extend(
["0" for i in range(random.randint(1, 10))])
self.assertRaises(
TypeError, model.predict, feature_states
) # Feature_states bad format: size of state not correspond to model features >
feature_states[state_id] = original.copy()
var_id = random.randint(0, len(dataset.features) - 1)
feature_states[state_id][var_id] = "bad_value"
self.assertRaises(
ValueError, model.predict, feature_states
) # Feature_states bad format: value out of domain
feature_states[state_id] = original.copy()