def learn_python_class(): """ Learn a Mealy machine where inputs are methods and arguments of the class that serves as SUL. :return: Mealy machine """ # class from aalpy.SULs import PyClassSUL, FunctionDecorator from aalpy.oracles import StatePrefixEqOracle from aalpy.learning_algs import run_Lstar from aalpy.utils import MockMqttExample, visualize_automaton mqtt = MockMqttExample input_al = [FunctionDecorator(mqtt.connect), FunctionDecorator(mqtt.disconnect), FunctionDecorator(mqtt.subscribe, 'topic'), FunctionDecorator(mqtt.unsubscribe, 'topic'), FunctionDecorator(mqtt.publish, 'topic')] sul = PyClassSUL(mqtt) eq_oracle = StatePrefixEqOracle(input_al, sul, walks_per_state=20, walk_len=20) mealy = run_Lstar(input_al, sul, eq_oracle=eq_oracle, automaton_type='mealy', cache_and_non_det_check=True) visualize_automaton(mealy)
def train_and_extract_tomita(tomita_grammar, acc_stop=1., loss_stop=0.005, load=False): tomita_alphabet = ["0", "1"] if not load: rnn = train_RNN_on_tomita_grammar(tomita_grammar, acc_stop=acc_stop, loss_stop=loss_stop) else: rnn = train_RNN_on_tomita_grammar(tomita_grammar, train=False) rnn.load(f"RNN_Models/tomita_{tomita_grammar}.model") sul = RnnBinarySUL(rnn) alphabet = tomita_alphabet state_eq_oracle = StatePrefixEqOracle(alphabet, sul, walks_per_state=1000, walk_len=5) dfa = run_Lstar(alphabet=alphabet, sul=sul, eq_oracle=state_eq_oracle, automaton_type='dfa', cache_and_non_det_check=True) save_automaton_to_file(dfa, f'LearnedAutomata/learned_tomita{tomita_grammar}') visualize_automaton(dfa)
def learn_diff_drive_robot(visualize=False): all_faults = [ 'left_faster', 'left_slower', 'left_stuck', 'right_faster', 'right_slower', 'right_stuck' ] wheel_inputs = [(0, 0), (0, 2), (2, 0), (2, 2), (0, -2), (2, -2), (-2, 0), (-2, 2), (-2, -2)] alphabet = list(wheel_inputs) alphabet.extend(all_faults) sul = StrongFaultRobot(upper_speed_limit=10) eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=20, walk_len=15) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='mealy') if visualize: visualize_automaton(learned_model, display_same_state_trans=False) return learned_model
def learn_vending_machine(visualize=False): sul = VendingMachineSUL() alphabet = sul.alphabet eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=50, walk_len=20) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='mealy') # Example of a error sul = MealySUL(learned_model) print( sul.query(( 'add_coin_0.2', 'add_coin_0.5', 'add_coin_0.2', 'add_coin_0.2', 'add_coin_0.2', 'add_coin_0.2', ))) if visualize: visualize_automaton(learned_model, display_same_state_trans=False) return learned_model
def visualize(self, path='LearnedModel', file_type='pdf', display_same_state_transitions=True): from aalpy.utils import visualize_automaton visualize_automaton(self, path, file_type, display_same_state_transitions)
def find_cex(self, hypothesis): self.curr_hypothesis += 1 inputs = [] visualize_automaton(hypothesis, path=f'Hypothesis_{self.curr_hypothesis}') while True: inp = input('Please provide an input: ') if inp == 'print alphabet': print(self.alphabet) continue if inp == 'current inputs': print(inputs) continue if inp == 'cex': if inputs: return inputs if inp == 'end': return None if inp == 'reset': inputs.clear() hypothesis.reset_to_initial() print( 'You are back in the initial state. Please provide an input: ' ) continue if inp not in self.alphabet: print("Provided input is not in the input alphabet.") continue inputs.append(inp) out = hypothesis.step(inp) print('Output:', out)
def alergia_smm_example(): from aalpy.SULs import StochasticMealySUL from random import randint, choice from aalpy.learning_algs import run_Alergia from aalpy.utils import visualize_automaton, generate_random_smm smm = generate_random_smm(5, 2, 5) visualize_automaton(smm, path='Original') sul = StochasticMealySUL(smm) inputs = smm.get_input_alphabet() data = [] for _ in range(100000): str_len = randint(5, 15) sul.pre() seq = [] for _ in range(str_len): i = choice(inputs) o = sul.step(i) seq.append((i, o)) sul.post() data.append(seq) # run alergia with the data and automaton_type set to 'mdp' to True to learn a MDP model = run_Alergia(data, automaton_type='smm', eps=0.005, print_info=True) visualize_automaton(model) return model
def learn_date_validator(): from aalpy.base import SUL from aalpy.utils import visualize_automaton, DateValidator from aalpy.oracles import StatePrefixEqOracle from aalpy.learning_algs import run_Lstar class DateSUL(SUL): """ An example implementation of a system under learning that can be used to learn the behavior of the date validator. """ def __init__(self): super().__init__() # DateValidator is a black-box class used for date string verification # The format of the dates is %d/%m/%Y' # Its method is_date_accepted returns True if date is accepted, False otherwise self.dv = DateValidator() self.string = "" def pre(self): # reset the string used for testing self.string = "" pass def post(self): pass def step(self, letter): # add the input to the current string if letter is not None: self.string += str(letter) # test if the current sting is accepted return self.dv.is_date_accepted(self.string) # instantiate the SUL sul = DateSUL() # define the input alphabet alphabet = list(range(0, 9)) + ['/'] # define a equivalence oracle eq_oracle = StatePrefixEqOracle(alphabet, sul, walks_per_state=500, walk_len=15) # run the learning algorithm learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='dfa') # visualize the automaton visualize_automaton(learned_model)
def jAlergiaExample(): from aalpy.learning_algs import run_JAlergia from aalpy.utils import visualize_automaton # if you need more heap space check model = run_JAlergia(path_to_data_file='jAlergia/exampleMdpData.txt', automaton_type='mdp', eps=0.005, path_to_jAlergia_jar='jAlergia/alergia.jar', optimize_for='memory') # # alternatively pass the data in following form # mc_data = [[1,2,3,4,5], [1,2,3,4,2,1], [1,3,5,2,3]] # mdp_data = [[1,2,3,1,2], [1,3,6,4,2]] # model = run_JAlergia(path_to_data_file=mc_data, automaton_type='mdp', eps=0.005, # path_to_jAlergia_jar='jAlergia/alergia.jar', optimize_for='memory') visualize_automaton(model) return model
def learn_light_switch(visualize=False): alphabet = ['press', 'increase_delay', 'fix_delay'] # 'fix_delay' sul = LightSwitchSUL() eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=20, walk_len=15) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='moore') if visualize: visualize_automaton(learned_model, display_same_state_trans=False) return learned_model
def find_cex(self, hypothesis): self.reset_hyp_and_sul(hypothesis) self.curr_hypothesis += 1 inputs = [] visualize_automaton(hypothesis, path=f'Hypothesis_{self.curr_hypothesis}') while True: inp = input('Please provide an input: ') if inp == 'help': print( 'Use one of following commands [print alphabet, current inputs, cex, end, reset] ' 'or provide an input') continue if inp == 'print alphabet': print(self.alphabet) continue if inp == 'current inputs': print(inputs) continue if inp == 'cex': if inputs: self.sul.post() return inputs if inp == 'end': return None if inp == 'reset': inputs.clear() self.reset_hyp_and_sul(hypothesis) print( 'You are back in the initial state. Please provide an input: ' ) continue if inp not in self.alphabet: print("Provided input is not in the input alphabet.") continue inputs.append(inp) self.num_steps += 1 out_hyp = hypothesis.step(inp) out_sul = self.sul.step(inp) print('Hypothesis Output :', out_hyp) print('SUL Output :', out_sul) if out_hyp != out_sul: print( 'Counterexample found.\nIf you want to return it, type \'cex\'.' )
def learn_gearbox(visualize=False): alphabet = [ 'press_clutch', 'release_clutch', 'put_in_reverse', 'increase_gear', 'decrease_gear' ] sul = GearBoxSUL() eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=2000, walk_len=15) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='mealy') if visualize: visualize_automaton(learned_model, display_same_state_trans=False) return learned_model
def learn_wind_turbine(visualize=False): alphabet = [ 'increase_speed', 'stop_turbine', 'unexpected_speed_increase', 'unexpected_slow_down' ] sul = TurbineSUL() eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=20, walk_len=15) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='mealy') if visualize: visualize_automaton(learned_model, display_same_state_trans=False) return learned_model
def learn_coffee_machine_mbd(visualize=False): sul = FaultInjectedCoffeeMachineSUL() alphabet = ['coin', 'button', 'coin_double_value', 'button_no_effect'] eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=5000, walk_len=20) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='mealy', cache_and_non_det_check=False) if visualize: visualize_automaton(learned_model, display_same_state_trans=True) return learned_model
def learn_stochastic_coffee_machine(visualize=False): sul = StochasticCoffeeMachineSUL() alphabet = ['coin', 'button'] eq_oracle = UnseenOutputRandomWordEqOracle(alphabet, sul, num_walks=100, min_walk_len=5, max_walk_len=10) learned_model = run_stochastic_Lstar(alphabet, sul, eq_oracle, automaton_type='smm') if visualize: visualize_automaton(learned_model, display_same_state_trans=True) return learned_model
def learn_language_of_coffee_machine_error(visualize=False): sul = FaultyCoffeeMachineSULDFA() alphabet = ['coin', 'button'] eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=5000, walk_len=20) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='dfa', cache_and_non_det_check=True) if visualize: visualize_automaton(learned_model, display_same_state_trans=True) return learned_model
def learn_stochastic_light_switch(visualize=False): sul = StochasticLightSUL() alphabet = ['press', 'release'] eq_oracle = UnseenOutputRandomWordEqOracle(alphabet, sul, num_walks=100, min_walk_len=3, max_walk_len=7) learned_model = run_stochastic_Lstar(alphabet, sul, eq_oracle, automaton_type='smm') if visualize: visualize_automaton(learned_model, display_same_state_trans=True) return learned_model
def alergia_mc_example(): from os import remove from aalpy.SULs import McSUL from random import randint from aalpy.learning_algs import run_Alergia from aalpy.utils import visualize_automaton, generate_random_markov_chain from aalpy.utils import CharacterTokenizer mc = generate_random_markov_chain(10) visualize_automaton(mc, path='Original') sul = McSUL(mc) # note that this example shows writing to file just to show how tokenizer is used... # this step can ofc be skipped and lists passed to alergia data = [] for _ in range(20000): str_len = randint(4, 12) seq = [f'{sul.pre()}'] for _ in range(str_len): o = sul.step() seq.append(f'{o}') sul.post() data.append(''.join(seq)) with open('mcData.txt', 'w') as file: for seq in data: file.write(f'{seq}\n') file.close() # create tokenizer tokenizer = CharacterTokenizer() # parse data data = tokenizer.tokenize_data('mcData.txt') # run alergia with the data and automaton_type set to 'mc' to learn a Markov Chain model = run_Alergia(data, automaton_type='mc', eps=0.005, print_info=True) # print(model) visualize_automaton(model) remove('mcData.txt') return model
def learn_crossroad(visualize=False): sul = CrossroadSUL() alphabet = sul.full_alphabet eq_oracle = RandomWMethodEqOracle(alphabet, sul, walks_per_state=10, walk_len=30) learned_model = run_Lstar(alphabet, sul, eq_oracle, automaton_type='mealy', cache_and_non_det_check=False, max_learning_rounds=10) if visualize: visualize_automaton(learned_model, display_same_state_trans=False, file_type="dot") return learned_model
def mqtt_example(): from aalpy.base import SUL from aalpy.oracles import RandomWalkEqOracle from aalpy.learning_algs import run_Lstar from aalpy.utils import visualize_automaton, MockMqttExample class MQTT_SUL(SUL): def __init__(self): super().__init__() self.mqtt = MockMqttExample() def pre(self): self.mqtt.state = 'CONCLOSED' def post(self): self.mqtt.topics.clear() def step(self, letter): if letter == 'connect': return self.mqtt.connect() elif letter == 'disconnect': return self.mqtt.disconnect() elif letter == 'publish': return self.mqtt.publish(topic='test') elif letter == 'subscribe': return self.mqtt.subscribe(topic='test') else: return self.mqtt.unsubscribe(topic='test') sul = MQTT_SUL() input_al = ['connect', 'disconnect', 'publish', 'subscribe', 'unsubscribe'] eq_oracle = RandomWalkEqOracle(input_al, sul, num_steps=2000, reset_after_cex=True, reset_prob=0.15) mealy = run_Lstar(input_al, sul, eq_oracle=eq_oracle, automaton_type='mealy', cache_and_non_det_check=True, print_level=3) visualize_automaton(mealy)
def learn_with_mapper(): train_seq, train_labels, input_al, output_al = generate_concrete_data_MQTT( num_examples=300000, num_rand_topics=2, lens=(1, 2, 3, 5, 8, 10, 12), uniform_concretion=True) x_train, y_train, x_test, y_test = split_train_validation(train_seq, train_labels, 0.8, uniform=True) # train_seq, train_labels = generate_data_based_on_characterization_set(mealy_machine) # x_train, y_train, x_test, y_test = split_train_validation(train_seq, train_labels, 0.8, uniform=True) rnn = RNNClassifier(input_al, output_dim=len(output_al), num_layers=5, hidden_dim=40, x_train=x_train, y_train=y_train, x_test=x_test, y_test=y_test, batch_size=32, nn_type='GRU') load = True ex_name = 'abstracted_mqtt' if not load: rnn.train(epochs=200, stop_acc=1.0, stop_epochs=3) rnn.save(f'RNN_Models/{ex_name}.rnn') with open(f'RNN_Models/{ex_name}.pickle', 'wb') as handle: pickle.dump((input_al, output_al), handle, protocol=pickle.HIGHEST_PROTOCOL) else: rnn.load(f'RNN_Models/{ex_name}.rnn') with open(f'RNN_Models/{ex_name}.pickle', 'rb') as handle: inp_out_tuple = pickle.load(handle) input_al, output_al = inp_out_tuple[0], inp_out_tuple[1] rnn.token_dict = dict((c, i) for i, c in enumerate(input_al)) sul = Abstract_Mapper_MQTT_RNN_SUL(rnn, input_al, output_al) abstract_inputs = sul.abstract_inputs eq_oracle = StatePrefixEqOracle(abstract_inputs, sul, walks_per_state=100, walk_len=20) model = run_Lstar(abstract_inputs, sul, eq_oracle, automaton_type='mealy', cache_and_non_det_check=True, suffix_closedness=False) visualize_automaton(model) return model
sul = RnnBinarySUL(rnn) alphabet = tomita_alphabet state_eq_oracle = StatePrefixEqOracle(alphabet, sul, walks_per_state=200, walk_len=6) dfa = run_Lstar(alphabet=alphabet, sul=sul, eq_oracle=state_eq_oracle, automaton_type='dfa', cache_and_non_det_check=True) save_automaton_to_file(dfa, f'RNN_Models/tomita{3}') visualize_automaton(dfa) # train and extract balanced parentheses bp_model = train_and_extract_bp( path='TrainingDataAndAutomata/balanced()_2.txt', load=False) print("Print extracted model") print(bp_model) # train and learn mealy machine example coffee_machine_automaton = train_RNN_and_extract_FSM('coffee') save_automaton_to_file(coffee_machine_automaton, 'CoffeeMachineModel') mqtt_automaton = train_RNN_and_extract_FSM('mqtt') save_automaton_to_file(coffee_machine_automaton, 'MqttModel')