Python SmartWmethodEquivalenceChecker Examples

Example #1

File: learn_mealy_from_dotfile.py Project: TCatshoek/lstar

from equivalencecheckers.bruteforce import BFEquivalenceChecker
from equivalencecheckers.wmethod import WmethodEquivalenceChecker, SmartWmethodEquivalenceChecker
from learners.mealylearner import MealyLearner
from suls.mealymachine import MealyState, MealyMachine
from teachers.teacher import Teacher
from util.dotloader import load_mealy_dot

path = "/home/tom/projects/lstar/rers/industrial/m54.dot"

mm = load_mealy_dot(path)
mm.render_graph(tempfile.mktemp('.gv'), render_options={'ignore_self_edges': ['error', 'invalid']},)

# Use the W method equivalence checker
eqc = SmartWmethodEquivalenceChecker(mm,
                                     m=len(mm.get_states()) + 1,
                                     stop_on={'error'})



eqc.onCounterexample(lambda x: print('Counterexample:', x))

teacher = Teacher(mm, eqc)

# We are learning a mealy machine
learner = MealyLearner(teacher)

hyp = learner.run(
    show_intermediate=False,
    render_options={'ignore_self_edges': ['error', 'invalid']},
)

Example #2

File: arithmetictest.py Project: TCatshoek/lstar

    def reset(self):
        self.counter = 0
        self.last_action = None

    def get_alphabet(self):
        return ('add', 'sub', 'exec', 'show')


if __name__ == "__main__":
    sul = ArithmeticTest()

    #sul.process_input(['add', 'exec', 'show'])

    ct = CounterexampleTracker()

    eqc = SmartWmethodEquivalenceChecker(sul, horizon=3)

    eqc = StackedChecker(
        GeneticEquivalenceChecker(sul, ct, pop_n=100000),
        SmartWmethodEquivalenceChecker(sul, horizon=3, order_type='ce count'))

    eqc.onCounterexample(lambda ce: ct.add(ce))

    teacher = Teacher(sul, eqc)

    # We are learning a mealy machine
    learner = MealyLearner(teacher)

    def print_stats(hyp=None):
        print("Member queries:", teacher.member_query_counter)
        print("Equivalence queries:", teacher.equivalence_query_counter)

Example #3

File: learn_random_mealy.py Project: TCatshoek/lstar

from equivalencecheckers.wmethod import SmartWmethodEquivalenceChecker
from learners.mealylearner import MealyLearner
from teachers.teacher import Teacher
from util.mealygenerator import minimize, MakeRandomMealyMachine

# Randomly generate a mealy machine
A = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
O = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
mm = MakeRandomMealyMachine(200, A, O)
# It may not be minimal, so minimize it
mm = minimize(mm)

# Use the W method equivalence checker with early stopping
eqc = SmartWmethodEquivalenceChecker(mm,
                                     m=len(mm.get_states()),
                                     stop_on={'error'})

teacher = Teacher(mm, eqc)

learner = MealyLearner(teacher)

hyp = learner.run(show_intermediate=False)

assert len(hyp.get_states()) == len(mm.get_states())

print("done")

Example #4

# mm = DictCache(
#     load_mealy_dot(path),
#     storagepath=cache
# )#.load(cache)

mm = load_mealy_dot(path)

mm.render_graph(render_options={
    'ignore_self_edges': ['error', 'invalid'],
    'ignore_edges': ['error']
})

# Use the W method equivalence checker
eqc = SmartWmethodEquivalenceChecker(
    mm,
    #horizon=3,
    m=len(mm.get_states()),
    stop_on={'error'},
    order_type='ce count')

eqc.onCounterexample(lambda x: print('Counterexample:', x))

teacher = Teacher(mm, eqc)

# We are learning a mealy machine
learner = TTTMealyLearner(teacher)

hyp = learner.run(show_intermediate=False
                  #render_options={'ignore_self_edges': ['error', 'invalid']},
                  )

#hyp.render_graph(tempfile.mktemp('.gv'))

Example #5

File: learn_RERS_lstar.py Project: TCatshoek/lstar

problem = "Problem12"

# Since we are interacting with a real system, we will want to cache
# the responses so we don't unnecessarily repeat expensive queries
cache = f'cache/{problem}'
# The query caches are implemented as wrappers around the SUL classes
# they work transparently and only catch queries that have been asked previously
sul = RersTrieCache(RERSConnectorV4(
    f'../../rers/TrainingSeqReachRers2019/{problem}/{problem}'),
                    storagepath=cache).load(cache)

# We use a specialized W-method equivalence checker which features
# early stopping on invalid inputs, which speeds things up a lot
#eqc = RersWmethodEquivalenceChecker(sul, False, m=15)
eqc = SmartWmethodEquivalenceChecker(sul,
                                     horizon=10,
                                     stop_on={'invalid_input'},
                                     stop_on_startswith={'error'})
# Set up the teacher, with the system under learning and the equivalence checker
teacher = Teacher(sul, eqc)

# Set up the learner who only talks to the teacher
# We let it save checkpoints of every intermediate hypothesis
learner = MealyLearner(teacher)\
    .enable_checkpoints("checkpoints", problem)

# Get the learners hypothesis
hyp = learner.run(
    show_intermediate=True,
    render_options={'ignore_self_edges': ['error', 'invalid']},
    on_hypothesis=lambda x: check_result(
        x,