def custom_smm_example(smm,
n_c=20,
n_resample=100,
min_rounds=10,
max_rounds=500):
"""
Learning custom SMM.
:param smm: stochastic Mealy machine to learn
:param n_c: cutoff for a state to be considered complete
:param n_resample: resampling size
:param min_rounds: minimum number of learning rounds
:param max_rounds: maximum number of learning rounds
:return: learned SMM
"""
input_al = smm.get_input_alphabet()
sul = StochasticMealySUL(smm)
eq_oracle = UnseenOutputRandomWalkEqOracle(alphabet=input_al,
sul=sul,
num_steps=5000,
reset_prob=0.2,
reset_after_cex=True)
learned_model = run_stochastic_Lstar(input_al,
sul,
eq_oracle,
n_c=n_c,
n_resample=n_resample,
automaton_type='smm',
min_rounds=min_rounds,
max_rounds=max_rounds,
print_level=3)
return learned_model
def weird_coffee_machine_mdp_example():
"""
Learning faulty coffee machine that can be found in Chapter 5 and Chapter 7 of Martin's Tappler PhD thesis.
:return learned MDP
"""
mdp = get_weird_coffee_machine_MDP()
input_alphabet = mdp.get_input_alphabet()
sul = MdpSUL(mdp)
eq_oracle = UnseenOutputRandomWalkEqOracle(input_alphabet,
sul=sul,
num_steps=4000,
reset_prob=0.11,
reset_after_cex=True)
learned_mdp = run_stochastic_Lstar(input_alphabet,
sul,
eq_oracle,
n_c=20,
n_resample=1000,
min_rounds=10,
max_rounds=500,
strategy='normal',
cex_processing=None)
return learned_mdp
def onfsm_mealy_paper_example():
"""
Learning a ONFSM presented in 'Learning Finite State Models of Observable Nondeterministic Systems in a Testing
Context'.
:return: learned ONFSM
"""
from random import seed
seed(3)
onfsm = get_benchmark_ONFSM()
alph = onfsm.get_input_alphabet()
sul = OnfsmSUL(onfsm)
eq_oracle = UnseenOutputRandomWalkEqOracle(alph,
sul,
num_steps=5000,
reset_prob=0.09,
reset_after_cex=True)
eq_oracle = UnseenOutputRandomWordEqOracle(alph,
sul,
num_walks=500,
min_walk_len=4,
max_walk_len=10)
learned_onfsm = run_Lstar_ONFSM(alph,
sul,
eq_oracle,
n_sampling=15,
print_level=3)
return learned_onfsm
def random_onfsm_example(num_states, input_size, output_size, n_sampling):
"""
Generate and learn random ONFSM.
:param num_states: number of states of the randomly generated automaton
:param input_size: size of the input alphabet
:param output_size: size of the output alphabet
:param n_sampling: number of times each query will be repeated to ensure that all non-determinist outputs are
observed
:return: learned ONFSM
"""
onfsm = generate_random_ONFSM(num_states=num_states,
num_inputs=input_size,
num_outputs=output_size)
alphabet = onfsm.get_input_alphabet()
sul = OnfsmSUL(onfsm)
eq_oracle = UnseenOutputRandomWordEqOracle(alphabet,
sul,
num_walks=500,
min_walk_len=10,
max_walk_len=50)
eq_oracle = UnseenOutputRandomWalkEqOracle(alphabet,
sul,
num_steps=5000,
reset_prob=0.15,
reset_after_cex=True)
learned_model = run_Lstar_ONFSM(alphabet,
sul,
eq_oracle=eq_oracle,
n_sampling=n_sampling)
return learned_model
def test_learning_based_on_accuracy_based_stopping(self):
example = 'first_grid'
mdp = load_automaton_from_file(f'../DotModels/MDPs/{example}.dot', automaton_type='mdp')
min_rounds = 10
max_rounds = 500
from aalpy.automata import StochasticMealyMachine
from aalpy.utils import model_check_experiment, get_properties_file, \
get_correct_prop_values
from aalpy.automata.StochasticMealyMachine import smm_to_mdp_conversion
aalpy.paths.path_to_prism = "C:/Program Files/prism-4.6/bin/prism.bat"
aalpy.paths.path_to_properties = "../Benchmarking/prism_eval_props/"
stopping_based_on_prop = (get_properties_file(example), get_correct_prop_values(example), 0.02)
input_alphabet = mdp.get_input_alphabet()
automaton_type = ['mdp', 'smm']
similarity_strategy = ['classic', 'normal', 'chi2']
cex_processing = [None, 'longest_prefix']
samples_cex_strategy = [None, 'bfs', 'random:200:0.3']
for aut_type in automaton_type:
for strategy in similarity_strategy:
for cex in cex_processing:
for sample_cex in samples_cex_strategy:
sul = StochasticMealySUL(mdp) if aut_type == 'smm' else MdpSUL(mdp)
eq_oracle = UnseenOutputRandomWalkEqOracle(input_alphabet, sul=sul, num_steps=200,
reset_prob=0.25,
reset_after_cex=True)
learned_model = run_stochastic_Lstar(input_alphabet=input_alphabet, eq_oracle=eq_oracle,
sul=sul, n_c=20,
n_resample=1000, min_rounds=min_rounds,
max_rounds=max_rounds,
automaton_type=aut_type, strategy=strategy,
cex_processing=cex,
samples_cex_strategy=sample_cex, target_unambiguity=0.99,
property_based_stopping=stopping_based_on_prop,
print_level=0)
if isinstance(learned_model, StochasticMealyMachine):
mdp = smm_to_mdp_conversion(learned_model)
else:
mdp = learned_model
results, diff = model_check_experiment(get_properties_file(example),
get_correct_prop_values(example), mdp)
for d in diff.values():
if d > stopping_based_on_prop[2]:
assert False
assert True
def benchmark_mdp_2_smm_example(example='first_grid',
n_c=20,
n_resample=1000,
min_rounds=10,
max_rounds=500,
strategy='normal',
cex_processing=None,
reset_prob=0.125,
samples_cex_strategy=None):
"""
Learning the stochastic Mealy Machine(SMM) various benchmarking examples
found in Chapter 7 of Martin's Tappler PhD thesis.
:param n_c: cutoff for a state to be considered complete
:param n_resample: resampling size
:param example: One of ['first_grid', 'second_grid', 'shared_coin', 'slot_machine']
:param min_rounds: minimum number of learning rounds
:param max_rounds: maximum number of learning rounds
:param strategy: normal or no_cq
:param cex_processing: counterexample processing stategy
:param reset_prob: reset probability for random walk eq oracle
:param samples_cex_strategy: strategy to sample cex in the trace tree
:return: learned SMM
"""
mdp = load_automaton_from_file(f'./DotModels/MDPs/{example}.dot',
automaton_type='mdp')
input_alphabet = mdp.get_input_alphabet()
sul = StochasticMealySUL(mdp)
eq_oracle = UnseenOutputRandomWalkEqOracle(input_alphabet,
sul=sul,
num_steps=5000,
reset_prob=0.09,
reset_after_cex=True)
eq_oracle = UnseenOutputRandomWordEqOracle(input_alphabet,
sul,
num_walks=150,
min_walk_len=5,
max_walk_len=12,
reset_after_cex=True)
learned_mdp = run_stochastic_Lstar(
input_alphabet=input_alphabet,
eq_oracle=eq_oracle,
sul=sul,
n_c=n_c,
n_resample=n_resample,
min_rounds=min_rounds,
max_rounds=max_rounds,
automaton_type='smm',
strategy=strategy,
cex_processing=cex_processing,
samples_cex_strategy=samples_cex_strategy)
return learned_mdp
def test_non_det(self):
from aalpy.SULs import OnfsmSUL
from aalpy.oracles import UnseenOutputRandomWordEqOracle, UnseenOutputRandomWalkEqOracle
from aalpy.learning_algs import run_non_det_Lstar
from aalpy.utils import get_benchmark_ONFSM
onfsm = get_benchmark_ONFSM()
alphabet = onfsm.get_input_alphabet()
for _ in range(100):
sul = OnfsmSUL(onfsm)
oracle = UnseenOutputRandomWordEqOracle(alphabet,
sul,
num_walks=500,
min_walk_len=2,
max_walk_len=5)
learned_onfsm = run_non_det_Lstar(alphabet,
sul,
oracle,
n_sampling=50,
print_level=0)
eq_oracle = UnseenOutputRandomWalkEqOracle(alphabet,
sul,
num_steps=10000,
reset_prob=0.09,
reset_after_cex=True)
cex = eq_oracle.find_cex(learned_onfsm)
if cex or len(learned_onfsm.states) != len(onfsm.states):
assert False
assert True
def benchmark_mdp_example(example='first_grid',
n_c=20,
n_resample=1000,
min_rounds=10,
max_rounds=500,
strategy='normal'):
"""
Learning the MDP various benchmarking examples found in Chapter 7 of Martin's Tappler PhD thesis.
:param example: One of ['first_grid', 'second_grid', 'shared_coin', 'slot_machine']
:param n_c: cutoff for a state to be considered complete
:param n_resample: resampling size
:param min_rounds: minimum number of learning rounds
:param max_rounds: maximum number of learning rounds
:param strategy: normal or no_cq
:return: learned MDP
"""
mdp = load_automaton_from_file(f'./DotModels/MDPs/{example}.dot',
automaton_type='mdp')
input_alphabet = mdp.get_input_alphabet()
output_alphabet = list({state.output for state in mdp.states})
sul = MdpSUL(mdp)
eq_oracle = UnseenOutputRandomWalkEqOracle(input_alphabet,
sul=sul,
num_steps=5000,
reset_prob=0.09,
reset_after_cex=True)
eq_oracle = UnseenOutputRandomWordEqOracle(input_alphabet,
sul,
num_walks=500,
min_walk_len=10,
max_walk_len=100,
reset_after_cex=True)
learned_mdp = run_stochastic_Lstar(input_alphabet=input_alphabet,
sul=sul,
eq_oracle=eq_oracle,
n_c=n_c,
n_resample=n_resample,
min_rounds=min_rounds,
max_rounds=max_rounds,
strategy=strategy)
return learned_mdp
def random_mdp_example(num_states,
input_len,
num_outputs,
n_c=20,
n_resample=1000,
min_rounds=10,
max_rounds=1000):
"""
Generate and learn random MDP.
:param num_states: nubmer of states in generated MDP
:param input_len: size of input alphabet
:param n_c: cutoff for a state to be considered complete
:param n_resample: resampling size
:param num_outputs: size of output alphabet
:param min_rounds: minimum number of learning rounds
:param max_rounds: maximum number of learning rounds
:return: learned MDP
"""
mdp, input_alphabet = generate_random_mdp(num_states, input_len,
num_outputs)
sul = MdpSUL(mdp)
eq_oracle = UnseenOutputRandomWalkEqOracle(input_alphabet,
sul=sul,
num_steps=5000,
reset_prob=0.11,
reset_after_cex=True)
learned_mdp = run_stochastic_Lstar(input_alphabet,
sul,
eq_oracle,
n_c=n_c,
n_resample=n_resample,
min_rounds=min_rounds,
max_rounds=max_rounds)
return learned_mdp