def test_read_write_dset_go(self):
# Load a test mealy machine
mm_og = load_mealy_dot("../partition/rers_industrial_tests/m182.dot")
print("Original:", len(mm_og.get_states()), "States")
# Write it to disk
path = tempfile.mktemp(".dot")
_render(mm_og, path)
# And load it again
mm_loaded = load_mealy_dot(path, parse_rules=go_mealy_parser)
# Do we have the same amount of states?
self.assertEqual(
len(mm_og.get_states()),
len(mm_loaded.get_states()),
msg="Amount of states not equal")
# Do a W-method equivalence check to ensure the state machines are equal
eqc = WmethodEquivalenceChecker(mm_og, m=len(mm_og.get_states()))
equivalent, _ = eqc.test_equivalence(mm_loaded)
self.assertTrue(
equivalent,
msg="Loaded state machine is not equal to the original!"
)
def test_wmethod_different_problematic(self):
name = "testcases/m164.dot"
system = self.systems[name]
# Change one output
system2 = load_mealy_dot(name)
modified_state = [
state for state in system2.get_states() if state.name == '3'
][0]
# Choose random input
random_inp = 'usr2_ai3_re5'
og_next_state, og_out = modified_state.edges[random_inp]
modified_state.edges[random_inp] = (og_next_state,
'FKSLDJFKSLDJFLSKDJ')
print(
f"Modified state {modified_state.name}, action {random_inp} -> ({og_next_state.name}, {og_out})"
)
n_states = len(system.get_states())
eqc = WmethodEquivalenceChecker(system, m=n_states)
equivalent, _ = eqc.test_equivalence(system2)
self.assertFalse(equivalent, msg=f'Failure in {name}')
def test_ttt_wmethod(self):
eqc = WmethodEquivalenceChecker(self.dfa, m=len(self.dfa.get_states()))
teacher = Teacher(self.dfa, eqc)
learner = TTTDFALearner(teacher)
hyp = learner.run()
equivalent, _ = eqc.test_equivalence(hyp)
self.assertTrue(equivalent)
self.assertEqual(
len(self.dfa.get_states()),
len(hyp.get_states()),
)
def test_lstar_wmethod(self):
eqc = WmethodEquivalenceChecker(self.mm, m=len(self.mm.get_states()))
teacher = Teacher(self.mm, eqc)
learner = LStarMealyLearner(teacher)
hyp = learner.run()
equivalent, _ = eqc.test_equivalence(hyp)
self.assertTrue(equivalent)
self.assertEqual(
len(self.mm.get_states()),
len(hyp.get_states()),
)
def test_lstar_wmethod(self):
for name, system in self.systems.items():
n_states = len(system.get_states())
sul = DictCache(system)
eqc = WmethodEquivalenceChecker(sul, m=n_states)
teacher = Teacher(sul, eqc)
learner = LStarMealyLearner(teacher)
hyp = learner.run()
equivalent, _ = eqc.test_equivalence(hyp)
self.assertTrue(equivalent)
self.assertEqual(
n_states,
len(hyp.get_states()),
)
def test_wmethod_random_changes(self):
for i in range(10): # try a bunch of random changes
for name, system in self.systems.items():
# Change one output
system2 = load_mealy_dot(name)
modified_state = random.choice(system2.get_states())
# Choose random input
random_inp = random.choice(list(system.get_alphabet()))
og_next_state, og_out = modified_state.edges[random_inp]
modified_state.edges[random_inp] = (og_next_state,
'FKSLDJFKSLDJFLSKDJ')
print(
f"Modified state {modified_state.name}, action {random_inp} -> ({og_next_state.name}, {og_out})"
)
n_states = len(system.get_states())
eqc = WmethodEquivalenceChecker(system, m=n_states)
equivalent, _ = eqc.test_equivalence(system2)
self.assertFalse(equivalent, msg=f'Failure in {name}')
def test_lstar_bruteforce(self):
eqc = BFEquivalenceChecker(self.dfa, max_depth=len(self.dfa.get_states()))
teacher = Teacher(self.dfa, eqc)
learner = LStarDFALearner(teacher)
hyp = learner.run()
equivalent, _ = WmethodEquivalenceChecker(self.dfa, m=len(self.dfa.get_states())).test_equivalence(hyp)
self.assertTrue(equivalent)
self.assertEqual(
len(self.dfa.get_states()),
len(hyp.get_states()),
)
from stmlearn.equivalencecheckers import WmethodEquivalenceChecker
from stmlearn.learners import TTTMealyLearner
from stmlearn.teachers import Teacher
from stmlearn.util import MakeRandomMealyMachine
## Randomly generate a mealy machine and learn from it
# input alphabet
A = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
# output alphabet
O = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
# Generate a mealy machine and try to minimize it
# Minimization is kinda broken so may sometimes result in non-minimal mealy machines
# In this case the assertion below will fail
mm = MakeRandomMealyMachine(100, A, O, minimize=True)
# Use the W method equivalence checker
eqc = WmethodEquivalenceChecker(mm, m=len(mm.get_states()))
teacher = Teacher(mm, eqc)
learner = TTTMealyLearner(teacher)
hyp = learner.run(show_intermediate=False)
assert len(hyp.get_states()) == len(mm.get_states())
hyp.render_graph(tempfile.mktemp('.gv'))
print("done")
def test_wmethod_equal(self):
for name, system in self.systems.items():
n_states = len(system.get_states())
eqc = WmethodEquivalenceChecker(system, m=n_states)
equivalent, _ = eqc.test_equivalence(system)
self.assertTrue(equivalent)
from stmlearn.equivalencecheckers import WmethodEquivalenceChecker
from stmlearn.learners import LStarMealyLearner
from stmlearn.suls import MealyState, MealyMachine
from stmlearn.teachers import Teacher
# Set up an example mealy machine
s1 = MealyState('1')
s2 = MealyState('2')
s3 = MealyState('3')
s1.add_edge('a', 'nice', s2)
s1.add_edge('b', 'B', s1)
s2.add_edge('a', 'nice', s3)
s2.add_edge('b', 'back', s1)
s3.add_edge('a', 'A', s3)
s3.add_edge('b', 'back', s1)
mm = MealyMachine(s1)
mm.render_graph(tempfile.mktemp('.gv'))
# Use the W method equivalence checker
eqc = WmethodEquivalenceChecker(mm)
teacher = Teacher(mm, eqc)
# We are learning a mealy machine
learner = LStarMealyLearner(teacher)
hyp = learner.run()
hyp.render_graph(tempfile.mktemp('.gv'))