def build_pomdp(program, formula): options = sp.BuilderOptions([formula]) options.set_build_state_valuations() options.set_build_choice_labels() options.set_build_all_labels() logger.debug("Start building the POMDP") return sp.build_sparse_model_with_options(program, options)
def test_explicit_builder(self): path = stormpy.examples.files.prism_dtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) # Fix variables in the program. module = prism_program.modules[0] s_var = module.get_integer_variable("s").expression_variable d_var = module.get_integer_variable("d").expression_variable # Construct the model options = stormpy.BuilderOptions([p.raw_formula for p in properties]) options.set_build_state_valuations() model_builder = stormpy.make_sparse_model_builder(prism_program, options) model = model_builder.build() # and export the model from building state_mapping = model_builder.export_lookup() #lookup 1 state = { s_var : prism_program.expression_manager.create_integer(3), d_var : prism_program.expression_manager.create_integer(0)} id = state_mapping.lookup(state) assert model.state_valuations.get_integer_value(id, s_var) == 3 assert model.state_valuations.get_integer_value(id, d_var) == 0 #lookup 2 state = { s_var : prism_program.expression_manager.create_integer(7), d_var : prism_program.expression_manager.create_integer(3)} id = state_mapping.lookup(state) assert model.state_valuations.get_integer_value(id, s_var) == 7 assert model.state_valuations.get_integer_value(id, d_var) == 3
def example_building_models_04(): path = stormpy.examples.files.prism_mdp_firewire prism_program = stormpy.parse_prism_program(path) prism_program = stormpy.preprocess_symbolic_input( prism_program, [], "delay=10,fast=0.8")[0].as_prism_program() options = stormpy.BuilderOptions() options.set_build_state_valuations() options.set_build_all_reward_models(True) options.set_build_choice_labels(True) def permissive_policy(state_valuation, action_index): """ Whether for the given state and action, the action should be allowed in the model. :param state_valuation: :param action_index: :return: True or False """ action_name = prism_program.get_action_name(action_index) print(f"{state_valuation.to_json()}, {action_name}") # conditions on the action cond1 = action_name.startswith("snd") # conditions on the state (efficient) cond2 = state_valuation.get_integer_value( prism_program.get_module("node2").get_integer_variable( "x2").expression_variable) < 20 # conditions on the json repr of the state (inefficient, string handling, etc) cond3 = json.loads(str(state_valuation.to_json()))["x1"] < 40 return (cond1 or (cond2 and cond3)) constructor = stormpy.make_sparse_model_builder( prism_program, options, stormpy.StateValuationFunctionActionMaskDouble(permissive_policy)) model = constructor.build() print(model)
def example_simulator_01(): path = stormpy.examples.files.prism_dtmc_die prism_program = stormpy.parse_prism_program(path) model = stormpy.build_model(prism_program) simulator = stormpy.simulator.create_simulator(model, seed=42) final_outcomes = dict() for n in range(1000): while not simulator.is_done(): observation = simulator.step() if observation not in final_outcomes: final_outcomes[observation] = 1 else: final_outcomes[observation] += 1 simulator.restart() print(final_outcomes) options = stormpy.BuilderOptions([]) options.set_build_state_valuations() model = stormpy.build_sparse_model_with_options(prism_program, options) simulator = stormpy.simulator.create_simulator(model, seed=42) simulator.set_observation_mode(stormpy.simulator.SimulatorObservationMode.PROGRAM_LEVEL) final_outcomes = dict() for n in range(1000): while not simulator.is_done(): observation = simulator.step() if observation not in final_outcomes: final_outcomes[observation] = 1 else: final_outcomes[observation] += 1 simulator.restart() print(", ".join([f"{str(k)}: {v}" for k,v in final_outcomes.items()]))
def _build_model(self, instance, with_origins=True, register_stats=True): """ Build a (sparse) model from the given prism program instance :param instance: A highlevel description of the model :param with_origins: If the model is to be analysed with highlevel counterex, then this flag should be true. :param register_stats: Should the stats for this model be registered. Put to False, when the model is just build for debugging purposes. :return: The Markov chain. """ start_mb = time.time() assert len(self.properties) + len(self.qualitative_properties) > 0 or self._optimality if with_origins: raw_formulae = [p.property.raw_formula for p in self.properties] if self._optimality: raw_formulae.append(self._optimality.criterion.raw_formula) options = stormpy.BuilderOptions(raw_formulae) options.set_build_with_choice_origins(True) options.set_add_overlapping_guards_label() model = stormpy.build_sparse_model_with_options(instance, options) else: model = stormpy.build_model(instance, [p.property for p in self.properties]) self._print_overlapping_guards(model) model.reduce_to_state_based_rewards() building_time = time.time() - start_mb if register_stats: self.stats.report_model_building(building_time, model.nr_states) logger.debug("Build model with {} states in {} seconds".format(model.nr_states, building_time)) assert len(model.initial_states) == 1 #logger.debug(instance) return model
def example_building_models_03(): path = stormpy.examples.files.prism_pdtmc_brp prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=5]" properties = stormpy.parse_properties_for_prism_program( formula_str, prism_program) options = stormpy.BuilderOptions([p.raw_formula for p in properties]) options.set_build_state_valuations() model = stormpy.build_sparse_parametric_model_with_options( prism_program, options) valuations = model.state_valuations values2 = json.loads(str(valuations.get_json(2))) print(values2) integer_variables = [] for module in prism_program.modules: print("module {}".format(module.name)) integer_variables += module.integer_variables print(", ".join([ "{}: {}".format( str(iv.name), valuations.get_integer_value(2, iv.expression_variable)) for iv in integer_variables ]))
def test_choice_origins(self): program, _ = stormpy.parse_jani_model(get_example_path("dtmc", "die.jani")) a = stormpy.FlatSet() options = stormpy.BuilderOptions() options.set_build_with_choice_origins() model = stormpy.build_sparse_model_with_options(program, options) a = model.choice_origins.get_edge_index_set(3)
def build_pomdp(program): options = sp.BuilderOptions([]) options.set_build_state_valuations() options.set_build_choice_labels() options.set_build_all_labels() options.set_build_all_reward_models() model = sp.build_sparse_model_with_options(program, options) model = sp.pomdp.make_canonic(model) return model
def example_simulator_02(): path = stormpy.examples.files.prism_mdp_maze prism_program = stormpy.parse_prism_program(path) model = stormpy.build_model(prism_program) simulator = stormpy.simulator.create_simulator(model, seed=42) # 5 paths of at most 20 steps. paths = [] for m in range(5): path = [] state, reward, labels = simulator.restart() path = [f"{state}"] for n in range(20): actions = simulator.available_actions() select_action = random.randint(0,len(actions)-1) #print(f"Randomly select action nr: {select_action} from actions {actions}") path.append(f"--act={actions[select_action]}-->") state, reward, labels = simulator.step(actions[select_action]) #print(state) path.append(f"{state}") if simulator.is_done(): #print("Trapped!") break paths.append(path) for path in paths: print(" ".join(path)) options = stormpy.BuilderOptions() options.set_build_state_valuations() options.set_build_choice_labels(True) model = stormpy.build_sparse_model_with_options(prism_program, options) print(model) simulator = stormpy.simulator.create_simulator(model, seed=42) simulator.set_observation_mode(stormpy.simulator.SimulatorObservationMode.PROGRAM_LEVEL) simulator.set_action_mode(stormpy.simulator.SimulatorActionMode.GLOBAL_NAMES) # 5 paths of at most 20 steps. paths = [] for m in range(5): path = [] state, reward, labels = simulator.restart() path = [f"{state}"] for n in range(20): actions = simulator.available_actions() select_action = random.randint(0,len(actions)-1) #print(f"Randomly select action nr: {select_action} from actions {actions}") path.append(f"--act={actions[select_action]}-->") state, reward, labels = simulator.step(actions[select_action]) #print(state) path.append(f"{state}") if simulator.is_done(): #print("Trapped!") break paths.append(path) for path in paths: print(" ".join(path))
def test_label(self): program = stormpy.parse_prism_program( get_example_path("dtmc", "brp-16-2.pm")) properties = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) options = stormpy.BuilderOptions([p.raw_formula for p in properties]) options.set_build_choice_labels(True) model = stormpy.build_sparse_model_with_options(program, options) clabeling = model.choice_labeling clabels = clabeling.get_labels() assert len(clabels) == 7 assert "aB" in clabels assert "aA" in clabels assert "NewFile" in clabeling.get_labels_of_choice(0) assert "aG" in clabeling.get_labels_of_choice(7)
def initialize(cls, formulae): # builder options cls.builder_options = stormpy.BuilderOptions(formulae) cls.builder_options.set_build_with_choice_origins(True) cls.builder_options.set_build_state_valuations(True) cls.builder_options.set_add_overlapping_guards_label() # model checking environment cls.environment = stormpy.Environment() se = cls.environment.solver_environment se.set_linear_equation_solver_type(stormpy.EquationSolverType.gmmxx) # se.minmax_solver_environment.precision = stormpy.Rational(Property.mc_precision) # se.minmax_solver_environment.method = stormpy.MinMaxMethod.policy_iteration se.minmax_solver_environment.method = stormpy.MinMaxMethod.value_iteration
def build_model(self): ## Different build functions depending on the model format. if self.file_type == ".prism" or self.file_type == ".jani": ## Defining build options to ensure that choice labels remain. options = stormpy.BuilderOptions() options.set_build_state_valuations() options.set_build_choice_labels() self.model = stormpy.build_sparse_model_with_options( self.program, options) elif self.file_type == ".drn": ## Defining build options to ensure that choice labels remain. parser_options = stormpy.DirectEncodingParserOptions() parser_options.build_choice_labels = True self.model = stormpy.build_model_from_drn(self.file_path, parser_options) else: raise Exception("Model file type not supported to build models")
def createHypothesis(self): print() print('Building hypothesis MRM...') RM = self.OT.build_hypothesis() print('Hypothesis MRM built !') self.buildProductAutomaton( RM) # Write the prism file with the hypothesis program = stormpy.parse_prism_program(TMP_MODEL_PATH) properties = stormpy.parse_properties_for_prism_program( "Rmax=? [ LRA ]", program) options = stormpy.BuilderOptions(True, True) #To keep rewards and labels self.h = stormpy.build_sparse_model_with_options(program, options) self.result_h = stormpy.model_checking(self.h, properties[0], extract_scheduler=True).at(0) self.scheduler = stormpy.model_checking( self.h, properties[0], extract_scheduler=True).scheduler
def example_analysis_04(): path = stormpy.examples.files.prism_dtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties(formula_str, prism_program) options = stormpy.BuilderOptions([p.raw_formula for p in properties]) options.set_build_state_valuations() model = stormpy.build_sparse_model_with_options(prism_program, options) result = stormpy.model_checking(model, properties[0]) # Print the model checking result for all states print("Model checking results:") for i in range(len(model.states)): print("\tstate #{}\t {}:\t {}".format( i, model.state_valuations.get_string(i), result.at(i)))
def build_model(self, jani_program, formulae, alt_formulae): if self._model: logger.warning("Rebuilding a model...") logger.info("Build model...") options = stormpy.BuilderOptions(formulae) options.set_build_with_choice_origins(True) options.set_add_overlapping_guards_label() self._formulae = formulae self._alt_formulae = alt_formulae self._expression_manager = jani_program.expression_manager result = stormpy.build_sparse_model_with_options(jani_program, options) logger.info( "done. Model has {} states, {} actions and {} transitions".format( result.nr_states, result.nr_choices, result.nr_transitions)) self._model = result self._submodel = self._model self._print_overlapping_guards(self._model) return self._model
def build_model(program, formula, exact_arithmetic): """ Takes a model and a formula that describes the bad event. :param program: PRISM program :param formula: a PCTL specification for a bad event :param exact_arithmetic: Flag for using exact arithmetic. :return: A sparse MDP """ options = sp.BuilderOptions([formula]) options.set_build_state_valuations() options.set_build_observation_valuations() options.set_build_choice_labels() options.set_build_all_labels() logger.debug("Start building the MDP") if exact_arithmetic: return sp.build_sparse_exact_model_with_options(program, options) else: return sp.build_sparse_model_with_options(program, options)
def main(): path = stormpy.examples.files.prism_pomdp_maze prism_program = stormpy.parse_prism_program(path) options = stormpy.BuilderOptions() options.set_build_state_valuations() options.set_build_choice_labels() pomdp = stormpy.build_sparse_model_with_options(prism_program, options) pomdp = stormpy.pomdp.make_canonic(pomdp) memory_builder = stormpy.pomdp.PomdpMemoryBuilder() memory = memory_builder.build( stormpy.pomdp.PomdpMemoryPattern.selective_counter, 2) pomdp = stormpy.pomdp.unfold_memory(pomdp, memory,\ add_memory_labels=True, keep_state_valuations=True) pomdp = stormpy.pomdp.make_simple(pomdp, keep_state_valuations=True) pmc = stormpy.pomdp.apply_unknown_fsc( pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) stormpy.export_to_drn(pmc, "test.drn") test = stormpy.build_parametric_model_from_drn("test.drn")
def execute(self): to_add = [self.states[-1]] while len(to_add) > 0: next_add = to_add.pop(0) to_add += self.createNewMdp(next_add[0], next_add[1]) self.createPrismModel() program = stormpy.parse_prism_program(TMP_MODEL_PATH) if self.mode == MODE_MAX: prop = 'Pmax=? [F "target"]' if self.mode == MODE_MIN: prop = 'Rmin=? [F "target"]' properties = stormpy.parse_properties_for_prism_program(prop, program) options = stormpy.BuilderOptions(True, True) #To keep rewards and labels built_model = stormpy.build_sparse_model_with_options(program, options) #compute prop--------------------------------------------------------------- result = stormpy.model_checking(built_model, properties[0], extract_scheduler=True) #extract scheduler---------------------------------------------------------- scheduler = result.scheduler #print(scheduler) self.scheduler_nrmdp = [] for i in range(len(self.model.map.states)): self.scheduler_nrmdp.append([]) for j in range(len(self.observations) + 1): self.scheduler_nrmdp[-1].append(-1) for state in built_model.states: if not "sink" in state.labels: state_lbl = self.getStateInNRMDP(state.labels) self.scheduler_nrmdp[state_lbl[0]][ state_lbl[1]] = scheduler.get_choice( state).get_deterministic_choice()
def example_parametric_models_01(): # Check support for parameters if not config.storm_with_pars: print("Support parameters is missing. Try building storm-pars.") return import stormpy.pars from pycarl.formula import FormulaType, Relation if stormpy.info.storm_ratfunc_use_cln(): import pycarl.cln.formula else: import pycarl.gmp.formula # Prevent curious side effects from earlier runs (for tests only) pycarl.clear_pools() # ### # # How to apply an unknown FSC to obtain a pMC from a POMDP # path = stormpy.examples.files.prism_pomdp_maze # prism_program = stormpy.parse_prism_program(path) # # formula_str = "P=? [!\"bad\" U \"goal\"]" # properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) # # construct the POMDP # pomdp = stormpy.build_model(prism_program, properties) # # make its representation canonic. # pomdp = stormpy.pomdp.make_canonic(pomdp) # # make the POMDP simple. This step is optional but often beneficial # pomdp = stormpy.pomdp.make_simple(pomdp) # # construct the memory for the FSC # # in this case, a selective counter with two states # memory_builder = stormpy.pomdp.PomdpMemoryBuilder() # memory = memory_builder.build(stormpy.pomdp.PomdpMemoryPattern.selective_counter, 2) # # apply the memory onto the POMDP to get the cartesian product # pomdp = stormpy.pomdp.unfold_memory(pomdp, memory) # # apply the memory onto the POMDP to get the cartesian product # pmc = stormpy.pomdp.apply_unknown_fsc(pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) #### # How to apply an unknown FSC to obtain a pMC from a pPOMDP path = stormpy.examples.files.prism_par_pomdp_maze prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [!\"bad\" U \"goal\"]" properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) # construct the pPOMDP options = stormpy.BuilderOptions([p.raw_formula for p in properties]) options.set_build_state_valuations() options.set_build_choice_labels() pomdp = stormpy.build_sparse_parametric_model_with_options(prism_program, options) # make its representation canonic. pomdp = stormpy.pomdp.make_canonic(pomdp) # construct the memory for the FSC # in this case, a selective counter with two states memory_builder = stormpy.pomdp.PomdpMemoryBuilder() memory = memory_builder.build(stormpy.pomdp.PomdpMemoryPattern.selective_counter, 3) # apply the memory onto the POMDP to get the cartesian product pomdp = stormpy.pomdp.unfold_memory(pomdp, memory, add_memory_labels=True, keep_state_valuations=True) # make the POMDP simple. This step is optional but often beneficial pomdp = stormpy.pomdp.make_simple(pomdp, keep_state_valuations=True) # apply the unknown FSC to obtain a pmc from the POMDP pmc = stormpy.pomdp.apply_unknown_fsc(pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) export_pmc = False # Set to True to export the pMC as drn. if export_pmc: export_options = stormpy.core.DirectEncodingOptions() export_options.allow_placeholders = False stormpy.export_to_drn(pmc, "test.out", export_options)
def prism_to_consmdp(filename, constants=None, state_valuations=True, action_labels=True, return_targets=False): """ Build a ConsMDP from a PRISM symbolic description using Stormpy. The model must specify `consumption` reward on each action (choice) and it needs to contain `reload` label. The following code sets the consumption of each action to `1` and marks each state where the variable `rel` is equal to `1` as a reloading state. >>> rewards "consumption" >>> [] true: 1; >>> endrewards >>> label "reload" = (rel=1); The dict `constants` must be given if a parametric prism model is to be read. It must defined all unused constants of the parametric model that affect the model's state space. On the other hand, it must not be defined if the model is not parametric. The format of the dictionary is `{ "constant_name" : constant_value }` where constant value is either an integer or a string that contains a name of other constant. :param filename: Path to the PRISM model. Must be an mdp. :param constants: Dictionary for uninitialized constant initialization. :type: constants: dict[str(constant_names) -> int/str(constant_names)] :param state_valuations: If True (default), set the valuation of states as names in the resulting ConsMDP. :param action_labels: If True (default), copies the choice labels in the PRISM model into the ConsMDP as action labels. :param return_targets: If True (default False), return also the list of states labeled by the label `target`. :return: ConsMDP object for the given model, or `ConsMDP, targets` if `return_targets` """ prism_prog = stormpy.parse_prism_program(filename) if constants is None: constants = {} elif not prism_prog.has_undefined_constants and len(constants) > 0: raise ValueError("There are no constants to be defined") prism_constants = {} man = prism_prog.expression_manager for const, value in constants.items(): var = man.get_variable(const) if type(value) == int: expression = man.create_integer(value) elif type(value) == str: expression = man.get_variable(value).get_expression() # elif type(value) == stormpy.storage.Expression: # expression = value else: raise ValueError("Constants values must be either int, " "str (a name of another constant), or " "a stormpy Expression.") prism_constants[var] = expression prism_prog = prism_prog.define_constants(prism_constants) options = stormpy.BuilderOptions() if state_valuations: options.set_build_state_valuations() if action_labels: options.set_build_choice_labels() model = stormpy.build_sparse_model_with_options(prism_prog, options) res = storm_sparsemdp_to_consmdp(model, state_valuations=state_valuations, action_labels=action_labels, return_targets=return_targets) return res
import stormpy import stormpy.info import matplotlib.pyplot as plt import numpy as np prism_program = stormpy.parse_prism_program("simp.nm") print("\n") print(prism_program.model_type) options = stormpy.BuilderOptions(True, True) options.set_build_state_valuations() options.set_build_choice_labels() model = stormpy.stormpy.build_sparse_model_with_options(prism_program, options) choice_labels = model.choice_labeling number = model.nr_states print("Number of states: {}" .format(model.nr_states)) print("Number of transitions: {}" .format(model.nr_transitions)) print("Labels: {}" .format(model.labeling.get_labels())) print() formula_str = 'R{\"states\"}min=? [F \"found\"]' #formula_str = 'Pmax=? [F \"found\"]' properties = stormpy.parse_properties(formula_str, prism_program) #model checking result = stormpy.model_checking(model, properties[0]) initial_state = model.states[0] # print("Expected number of steps to reach state from initial state: ", initial_state, " -> {}" .format(result.at(initial_state)))