def get_model(drn_file, solver_type=None): logging.debug("Get DRN model for pid {}".format(os.getpid())) global MODEL, VARS, INITIAL_STATE, PROPERTY, ENV, LOAD_TIME time_start = time.time() MODEL = stormpy.build_parametric_model_from_drn(drn_file) INITIAL_STATE = MODEL.initial_states[0] VARS = build.get_parameters(MODEL) properties = stormpy.parse_properties("R=? [F \"stable\"]") assert (len(properties) == 1) PROPERTY = properties[0] ENV = stormpy.Environment() if solver_type is not None: ENV.solver_environment.set_linear_equation_solver_type(solver_type) logging.info( "Model loaded for pid {}: {} states and {} transitions.".format( os.getpid(), MODEL.nr_states, MODEL.nr_transitions)) LOAD_TIME = time.time() - time_start
def example_getting_started_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) model = stormpy.build_model(prism_program, properties) print(model.model_type) for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: print("From state {}, with probability {}, go to state {}". format(state, transition.value(), transition.column))
def init_solver(threshold, model, env, program=None): """ Initialize PLA solver with new threshold :param threshold: Threshold. Can be None. :param model: Model. :param env: Environment. :param program: Prism program (optional). :return: Tuple (solver, environment) """ # Set formula with current threshold if threshold is None: prop = "R=? [F \"stable\"]" else: prop = "R<={} [F \"stable\"]".format(threshold) formulas = stormpy.parse_properties(prop, program) assert len(formulas) == 1 formula = formulas[0] return stormpy.pars.create_region_checker(env, model, formula.raw_formula)
def test_change_matrix_modelchecking(self): import stormpy.logic model = stormpy.build_sparse_model_from_explicit( get_example_path("dtmc", "die.tra"), get_example_path("dtmc", "die.lab")) matrix = model.transition_matrix # Check matrix for e in matrix: assert e.value() == 0.5 or e.value() == 0 or e.value() == 1 # First model checking formulas = stormpy.parse_properties("P=? [ F \"one\" ]") result = stormpy.model_checking(model, formulas[0]) resValue = result.at(model.initial_states[0]) assert math.isclose(resValue, 0.16666666666666663) # Change probabilities i = 0 for e in matrix: if e.value() == 0.5: if i % 2 == 0: e.set_value(0.3) else: e.set_value(0.7) i += 1 for e in matrix: assert e.value() == 0.3 or e.value() == 0.7 or e.value( ) == 1 or e.value() == 0 # Second model checking result = stormpy.model_checking(model, formulas[0]) resValue = result.at(model.initial_states[0]) assert math.isclose(resValue, 0.06923076923076932) # Change probabilities again for state in model.states: for action in state.actions: for transition in action.transitions: if transition.value() == 0.3: transition.set_value(0.8) elif transition.value() == 0.7: transition.set_value(0.2) # Third model checking result = stormpy.model_checking(model, formulas[0]) resValue = result.at(model.initial_states[0]) assert math.isclose(resValue, 0.3555555555555556)
def expCTMC(infile, outfile): prop = "Pmin=? [F \"Fail\"]" model = stormpy.build_model_from_drn(infile) proper = stormpy.parse_properties(prop) initial_state = model.initial_states[0] model, proper = stormpy.eliminate_non_markovian_chains( model, proper, stormpy.EliminationLabelBehavior.DELETE_LABELS) result = stormpy.model_checking(model, proper[0], extract_scheduler=True) intermediate = model.apply_scheduler(result.scheduler) model, proper = stormpy.eliminate_non_markovian_chains( intermediate, proper, stormpy.EliminationLabelBehavior.DELETE_LABELS) stormpy.export_to_drn(model, outfile) exit(1) fin = open(infile, 'r') lst = [] for line in fin: if "action 0" in line: continue else: lst.append(line) fin.close() fin = open(outfile, 'w+') for line in lst: fin.write(line) fin.close() if result.has_scheduler: scheduler = result.scheduler assert scheduler.memoryless assert scheduler.memory_size == 1 assert scheduler.deterministic intermediate = model.apply_scheduler(scheduler) #assert intermediate.model_type == stormpy.ModelType.MA for state in intermediate.states: assert len(state.actions) == 1 for state in intermediate.states: choice = scheduler.get_choice(state) action = choice.get_deterministic_choice() print("In state {} choose action {}".format(state, action)) else: print("I am here")
def example_dfts_01(): # Load from JSON path_json = stormpy.examples.files.dft_json_and dft_small = stormpy.dft.load_dft_json_file(path_json) print(dft_small) # Load from Galileo path = stormpy.examples.files.dft_galileo_hecs dft = stormpy.dft.load_dft_galileo_file(path) print("DFT with {} elements.".format(dft.nr_elements())) print("DFT has {} BEs and {} dynamic elements.".format( dft.nr_be(), dft.nr_dynamic())) # Analyze formula_str = "T=? [ F \"failed\" ]" formulas = stormpy.parse_properties(formula_str) results = stormpy.dft.analyze_dft(dft, [formulas[0].raw_formula]) result = results[0] print(result)
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 example_analysis_03(): 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) model = stormpy.build_model(prism_program, properties) env = stormpy.Environment() env.solver_environment.set_linear_equation_solver_type(stormpy.EquationSolverType.native) env.solver_environment.native_solver_environment.method = stormpy.NativeLinearEquationSolverMethod.power_iteration env.solver_environment.native_solver_environment.maximum_iterations = 2 result = stormpy.model_checking(model, properties[0], environment=env) print(result.at(model.initial_states[0])) dd_model = stormpy.build_symbolic_model(prism_program, properties) result = stormpy.model_checking(dd_model, properties[0], environment=env) filter = stormpy.create_filter_initial_states_symbolic(dd_model) result.filter(filter) assert result.min == result.max print(result.min)
def test_transform_continuous_to_discrete_time_model_ctmc(self): ctmc = stormpy.build_model_from_drn(get_example_path( "ctmc", "dft.drn")) formulas = stormpy.parse_properties("T=? [ F \"failed\" ]") assert ctmc.nr_states == 16 assert ctmc.nr_transitions == 33 assert len(ctmc.initial_states) == 1 initial_state = ctmc.initial_states[0] assert initial_state == 1 result = stormpy.model_checking(ctmc, formulas[0]) assert math.isclose(result.at(initial_state), 4.166666667) dtmc, dtmc_formulas = stormpy.transform_to_discrete_time_model( ctmc, formulas) assert dtmc.nr_states == 16 assert dtmc.nr_transitions == 33 assert len(dtmc.initial_states) == 1 initial_state = dtmc.initial_states[0] assert initial_state == 1 result = stormpy.model_checking(dtmc, dtmc_formulas[0]) assert math.isclose(result.at(initial_state), 4.166666667)
def example_exploration_01(): """ Example to exploration of MDPs. :return: """ program = stormpy.parse_prism_program( stormpy.examples.files.prism_pomdp_maze) prop = "R=? [F \"goal\"]" properties = stormpy.parse_properties(prop, program) model = stormpy.build_model(program, properties) print(model.model_type) for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: print( "From state {} by action {}, with probability {}, go to state {}" .format(state, action, transition.value(), transition.column))
def example_parametric_models_04(): # Check support for parameters if not config.storm_with_pars: print("Support parameters is missing. Try building storm-pars.") return import stormpy.pars path = stormpy.examples.files.prism_pdtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties(formula_str, prism_program) model = stormpy.build_parametric_model(prism_program, properties) # Modify i = 0 for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: if len(transition.value().gather_variables()) > 0: new_var = pycarl.Variable("p{}".format(i)) i += 1 new_pol = stormpy.Polynomial(new_var) pol_in_right_format = stormpy.FactorizedPolynomial(new_pol, transition.value().numerator.cache()) new_factorized_ratfunc = stormpy.FactorizedRationalFunction(pol_in_right_format) transition.set_value(new_factorized_ratfunc) # Display for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: print("From state {}, with probability {}, go to state {}".format(state, transition.value(), transition.column))
import time import aev_examples.read_cmdp_data from MRRP.MRRP_calculate import MRRP_by_pruned, MRRP_by_quotient cmdp_info = aev_examples.read_cmdp_data.cmdp_info("AEV_601_cap80", 80) mdp = cmdp_info.cmdp cap = cmdp_info.cap targets = cmdp_info.targets SF = cmdp_info.SF SFR = cmdp_info.SFR SFRR = cmdp_info.SFRR formula = 'Pmax=? [F "target" ]' prop = stormpy.parse_properties(formula) def MRRP_by_pruned(mdp, targets, cap, SF): pruned_mdp = cmdp2n_mdp.naive_flattened_mdp(mdp, targets, cap, SF) print("mdp convert to pruned one successfully") pruned_storm_mdp = consmdp_to_storm_consmdp(pruned_mdp, pruned_mdp.new_targets) print( f"pruned------The number of states in the explicit MDP in Storm: {pruned_storm_mdp.nr_states}" ) print(f"transitions number:{pruned_storm_mdp.nr_transitions}") storm_result = stormpy.model_checking(pruned_storm_mdp, prop[0]) for i in pruned_mdp.states:
def __init__(self, dtmc_generator, _lambda=0.005): self.dtmc_generator = dtmc_generator self.formula = stormpy.parse_properties("P=? [ F (\"far\" | \"collided\" | \"fallen\")]") self._lambda = _lambda
def test2(): t0 = time.time() #path = "collision_partial_obs_2d_upd_hobs_20_small.prism" path, interval_path, formula_str, threshold = input_files() prism_program = stormpy.parse_prism_program(path) #formula_str = "P=? [!\"bad\" U \"goal\"]" #formula_str = "P=? [F \"goal\"]" #interval_path="collision_partial_obs_2d_upd_hobs_20_small.intervals" opts = stormpy.DirectEncodingParserOptions() opts.build_choice_labels = True properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) # construct the pPOMDP import inspect print(inspect.getfullargspec(stormpy.build_parametric_model)) pomdp = stormpy.build_parametric_model(prism_program, properties) pomdp_parameters = pomdp.collect_probability_parameters() stormpy.export_parametric_to_drn(pomdp, "pomdp_ex") # make its representation canonic. pomdp = stormpy.pomdp.make_canonic(pomdp) #stormpy.export_parametric_to_drn(pomdp, "export_pomdp.drn") # construct the memory for the FSC # in this case, a selective counter with two states memory_builder = stormpy.pomdp.PomdpMemoryBuilder() memval=1 memory = memory_builder.build(stormpy.pomdp.PomdpMemoryPattern.selective_counter, memval) # apply the memory onto the POMDP to get the cartesian product pomdp = stormpy.pomdp.unfold_memory(pomdp, memory) print("Number of pomdp states before simple:",pomdp.nr_states) print("Number of transitions: {}".format(pomdp.nr_transitions)) # make the POMDP simple. This step is optional but often beneficial pomdp = stormpy.pomdp.make_simple(pomdp) print("Number of pomdp states after simple:",pomdp.nr_states) print("Number of transitions: {}".format(pomdp.nr_transitions)) # apply the unknown FSC to obtain a pmc from the POMDP pmc = stormpy.pomdp.apply_unknown_fsc(pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) print("Number of pomdp states after simple",pmc.nr_states) print("Number of transitions: {}".format(pmc.nr_transitions)) print(pmc) print("applied pmc") path_pmc = "export_" + str(memval) + "_mem_" + path print(path_pmc) stormpy.export_parametric_to_drn(pmc, path_pmc) print("built model") #print(model.initial_states) fsc_parameters = pmc.collect_probability_parameters() - pomdp.collect_probability_parameters() print("number of pomdp parameters:",len(fsc_parameters)) #print(fsc_parameters) #print(pomdp_parameters) #intervals2, polyhedrons = interval_parser.parse_input(interval_path) intervals, polyhedrons,items = interval_parser.parse_model_interval(pmc,pomdp_parameters,interval_path) #for item in intervals: #print(item,"printing in the main") #for item in items: # print(item,"printing in the main") for p in polyhedrons: #print(p) p.compute_vertices() properties = stormpy.parse_properties(formula_str) print("Building model from {}".format(path)) #parameters = model.collect_probability_parameters() print(pmc.nr_states) prob0E, prob1A = stormpy.prob01max_states(pmc, properties[0].raw_formula.subformula) #print(prob0E) #threshold = 0.90 direction = "below" # can be "below" or "above" options = QcqpOptions(mu=1e4, maxiter=10000, graph_epsilon=1e-2, silent=False) # result = solver.run(reward_model_name ,model_rew, parameters_rew, rew0, rew_threshold, direction, options) solver = QcqpSolver_affine_simple_fun() result = solver.run(pmc, fsc_parameters, pomdp_parameters,properties, prob0E, prob1A, threshold, direction, options,intervals,items,True) print("number of iterations={}".format(solver.iterations)) print("solver time={}".format(solver.solver_timer)) #compute the policy against the robust interval #interval_path="collision_partial_obs_2d_upd_hobs_20_small.intervals" intervals, polyhedrons,items = interval_parser.parse_model_interval(pmc,pomdp_parameters,interval_path) regiondict = dict() for x in pomdp_parameters: for item in items: if item.name == x.name: regiondict[x] = (stormpy.RationalRF(item.lowerbound), stormpy.RationalRF(item.upperbound)) region = stormpy.pars.ParameterRegion(regiondict) instantiator = stormpy.pars.PartialPDtmcInstantiator(pmc) instantiated_model = instantiator.instantiate(solver.solver_params) env = stormpy.Environment() env.solver_environment.set_linear_equation_solver_type(stormpy.EquationSolverType.eigen) env.solver_environment.native_solver_environment.method = stormpy.NativeLinearEquationSolverMethod.optimistic_value_iteration env.solver_environment.native_solver_environment.precision = stormpy.Rational('0.01') start_check = time.time() region_checker = stormpy.pars.create_region_checker(env, instantiated_model, properties[0].raw_formula, allow_model_simplification=False) print("region check") result = region_checker.get_bound_all_states(env, region, maximise=False) end_check = time.time() print("model checking ans:") ansval=result.at(pmc.initial_states[0]) print(ansval) tend = time.time() print("Total time: ", str(tend - t0))
def test(): #model path path = "pomdp_attempt_prob_36_sat_065_dist_5_obs_diff_orb_len_1.drn" #the specification string formula_str = "P=? [F \"goal\"]" # building options for stormpy opts = stormpy.DirectEncodingParserOptions() opts.build_choice_labels = True # build the model pomdp = stormpy.build_parametric_model_from_drn(path, opts) # path for the interval values interval_path="satellite_robust.intervals" # gather the interval parameters pomdp_parameters = pomdp.collect_probability_parameters() # make the pomdp canonic, which is required for simple transformation. pomdp = stormpy.pomdp.make_canonic(pomdp) # construct the memory for the FSC memory_builder = stormpy.pomdp.PomdpMemoryBuilder() #number of memory states in the FSC memval=1 # build the memory memory = memory_builder.build(stormpy.pomdp.PomdpMemoryPattern.selective_counter, memval) # apply the memory onto the POMDP to get the cartesian product pomdp = stormpy.pomdp.unfold_memory(pomdp, memory) print("Number of pomdp states before simple:",pomdp.nr_states) print("Number of transitions: {}".format(pomdp.nr_transitions)) # make the POMDP simple. pomdp = stormpy.pomdp.make_simple(pomdp) print("Number of pomdp states after simple:",pomdp.nr_states) print("Number of transitions: {}".format(pomdp.nr_transitions)) # apply the unknown FSC to obtain a pmc from the POMDP pmc = stormpy.pomdp.apply_unknown_fsc(pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) print("Number of pomdp states after simple",pmc.nr_states) print("Number of transitions: {}".format(pmc.nr_transitions)) print("applied pmc") path_pmc = "export_" + str(memval) + "_mem_" + path #export the resulting model file stormpy.export_parametric_to_drn(pmc, path_pmc) print("built model") fsc_parameters = pmc.collect_probability_parameters() - pomdp.collect_probability_parameters() print("number of pomdp parameters:",len(fsc_parameters)) # gather intervals and items from the model intervals, polyhedrons,items = interval_parser.parse_model_interval(pmc,pomdp_parameters,interval_path) for item in items: print(item,"printing in the main") properties = stormpy.parse_properties(formula_str) print("Building model from {}".format(path)) print(pmc.nr_states) #compute prob01max states for any policy prob0E, prob1A = stormpy.prob01max_states(pmc, properties[0].raw_formula.subformula) #compute threshold threshold = 0.9999 direction = "below" # can be "below" or "above" # solver parameters options = QcqpOptions(mu=1e4, maxiter=1000, graph_epsilon=1e-2, silent=False) # run solver solver = QcqpSolver_affine_simple_fun() result = solver.run(pmc, fsc_parameters, pomdp_parameters,properties, prob0E, prob1A, threshold, direction, options,intervals,items,True) print("number of iterations={}".format(solver.iterations)) print("solver time={}".format(solver.solver_timer)) print("solver time={}".format(solver.solver_timer))
def test_parse_formula(self): formula = "P=? [F \"one\"]" properties = stormpy.parse_properties(formula) assert len(properties) == 1 assert str(properties[0].raw_formula) == formula
def check(path_to_model, property_str): program = sp.parse_prism_program(path_to_model) props = sp.parse_properties(property_str, program) model = sp.build_model(program, props) result = sp.model_checking(model, props[0]) return result.at(model.initial_states[0]) > 0.5
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))) # print() i=0 re = [] while(i < number): initial_state = model.states[i] # print("Expected number of steps to reach state 'found' from state: ", initial_state, " -> {}" .format(result.at(initial_state))) re.append(result.at(initial_state)) i += 1
def find_optimum(self, model_file, verbose=False): logging.info("Running PLA on single process") self.verbose = verbose result = Result(model_file, self.config) # Get initial regions by computing the roots time_roots_start = time.time() roots = analyse.gather_roots(self.model, self.vars) result.time_roots = time.time() - time_roots_start logging.info("Computing roots took {}s".format(result.time_roots)) # Create initial intervals per parameter by splitting at roots initial_intervals = dict() for p in self.vars: initial_interval = [] current = 0 + self.config.eps # 0 and 1 change graph structure for root in roots[p]: initial_interval.append(Interval(current, root)) current = root initial_interval.append(Interval(current, 1 - self.config.eps)) initial_intervals[p] = initial_interval # Create initial regions initial_regions = [] for product in itertools.product(*initial_intervals.values()): region = { p.name: interval for p, interval in zip(self.vars, product) } initial_regions.append(Region(region)) if verbose: logging.debug("------------") for region in initial_regions: logging.debug("Initial region {}".format(region)) logging.debug("------------") properties = stormpy.parse_properties("R=? [F \"stable\"]") assert len(properties) == 1 property = properties[0] self.inst_checker = pla_helper.init_instantiation_checker( self.model, property, self.config.exact) # Find upper bound start_pla = time.time() logging.info("No. initial regions: {}".format(len(initial_regions))) upper_bound, best_sample = self.sample_points(self.vars, self.config.no_samples) logging.info("Found upper bound {} for sample {}".format( upper_bound, best_sample)) logging.debug("Time: {:.3f}s".format(time.time() - start_pla)) if not self.config.exact: # Slightly increase upper bound to avoid precision issues upper_bound += 1e-4 lower_bound = 0 self.solver = pla_helper.init_solver(None, self.model, self.env) # Find optimum by iterating the following: # - use PLA (minimize) to obtain lower bounds # - discard all regions whose minimal result is greater than the current upper bound # - sample remaining regions to improve upper bound # - split remaining regions in half start_time_pla = time.time() regions = initial_regions iteration = 0 if self.config.exact: precision = stormpy.Rational(self.config.precision) else: precision = self.config.precision while upper_bound - lower_bound > precision: iteration += 1 if iteration == 1: # Use initial regions new_regions = regions else: # Split regions new_regions = [] for region in regions: # Split region into two self.no_splits += 1 new_regions.extend(region.split(self.vars)) regions, sample, lower_bound, upper_bound = self.compute_satisfying_regions( upper_bound, new_regions) iteration_time = time.time() - start_time_pla start_time_pla = time.time() logging.info( "Iteration {}: bounds: [{}, {}], best sample: {}, {} regions remaining, {} calls, {} splits, time: {:.3f}s" .format(iteration, lower_bound, upper_bound, best_sample, len(regions), self.no_calls, self.no_splits, iteration_time)) if sample is not None: best_sample = sample if verbose: logging.debug("------------") if self.config.exact: logging.debug( "Current bounds: [{}, {}], precision: {}".format( lower_bound, upper_bound, upper_bound - lower_bound)) else: logging.debug( "Current bounds: [{}, {}], precision: {:.1e}".format( lower_bound, upper_bound, upper_bound - lower_bound)) logging.debug("Best sample: {}".format(best_sample)) tmp = sort_regions(list(regions), self.vars) for region in tmp: logging.debug("Region {}".format(region)) logging.debug("Time: {:.3f}s".format(time.time() - start_time_pla)) logging.debug("------------") logging.info( "Remaining regions: {}, best sample: {}, {} calls, {} splits". format(len(regions), best_sample, self.no_calls, self.no_splits)) end_pla = time.time() result.time_analysis = end_pla - start_pla result.result_ert = Interval(lower_bound, upper_bound) result.best_sample = best_sample result.result_region = sort_regions(regions, self.vars) return result
def unfolding(simulator, unfolder, trace_length, stats_file, deadline=None, terminate_on_deadline=True, use_ovi=False): """ :param simulator: The simulator that spits out the observations :param tracker: The tracker that keeps track of the state estimation :param trace_length: How many steps to take. :param stats_file: The file to output all the statistics to. :param deadline: The deadline for every computation step :param terminate_on_deadline: Should we abort the trace if we exceeded computation time :param use_ovi: Whether to use OVI or not. :return: """ #TODO make the stats_file optional observation, _ = simulator.restart() unfolder.reset(observation) env = stormpy.Environment() if use_ovi: env.solver_environment.minmax_solver_environment.method = stormpy.MinMaxMethod.optimistic_value_iteration env.solver_environment.minmax_solver_environment.precision = stormpy.Rational( "0.01") with open(stats_file, 'w') as file: writer = csv.writer(file) writer.writerow([ "Index", "Observation", "Risk", "UnfTime", "McTime", "TotalTime", "MdpStates", "MdpTransitions", "TimedOut" ]) for i in tqdm(range(trace_length)): observation, _ = simulator.random_step() start_time = time.monotonic() mdp = unfolder.extend(observation) end_time = time.monotonic() unfold_time = end_time - start_time #stormpy.export_to_drn(mdp,"unrolling.out") prop = sp.parse_properties("Pmax=? [F \"_goal\"]")[0] # #mdpl = stormpy.build_model_from_drn("unrolling.out") timeout = False start_time = time.monotonic() stormpy.reset_timeout() stormpy.set_timeout(int(deadline / 1000)) stormpy.install_signal_handlers() try: result = stormpy.model_checking(mdp, prop, environment=env, only_initial_states=True) risk = result.at(0) except RuntimeError: timeout = True stormpy.reset_timeout() end_time = time.monotonic() mc_time = end_time - start_time total_time = unfold_time + mc_time if deadline and total_time * 1000 > deadline: timeout = True writer.writerow([ i, observation, risk, unfold_time, mc_time, total_time, mdp.nr_states, mdp.nr_transitions, timeout ]) file.flush() if terminate_on_deadline and timeout: return False return True