def test_pla(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.create_region_checker(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string( "0.7<=pL<=0.9,0.75<=pK<=0.95", parameters, splitting_threshold=None) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLSAT region = stormpy.pars.ParameterRegion.create_from_string( "0.4<=pL<=0.65,0.75<=pK<=0.95", parameters, splitting_threshold=None) result = checker.check_region( env, region, stormpy.pars.RegionResultHypothesis.UNKNOWN, stormpy.pars.RegionResult.UNKNOWN, True) assert result == stormpy.pars.RegionResult.EXISTSBOTH region = stormpy.pars.ParameterRegion.create_from_string( "0.1<=pL<=0.73,0.2<=pK<=0.715", parameters, splitting_threshold=None) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLVIOLATED
def initialize(self): logger.debug("Initialize oracle...") formula_str = "Pmax=? [F \"goal\"]" properties = stormpy.parse_properties(formula_str, self._get_prism_program()) logger.debug("...building model...") self._model = stormpy.build_symbolic_model(self._get_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 = 100 logger.debug("...doing model checking...") self._mc_result = stormpy.model_checking(self._model, properties[0], environment=env) logger.debug("Initialization done.")
def __init__(self, model, config): self.verbose = False self.no_splits = 0 self.no_calls = 0 self.config = config self.model = model self.vars = build.get_parameters(model) self.initial_state = model.initial_states[0] self.env = stormpy.Environment() if config.linear_equation_solver is not None: self.env.solver_environment.set_linear_equation_solver_type( config.linear_equation_solver) self.inst_checker = None self.solver = None
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 __init__(self, model, program, config, verbose=False): self.model = model self.program = program self.config = config self.verbose = verbose vars = build.get_parameters(model) assert len(vars) == 1 self.var = vars[0] self.env = stormpy.Environment() if config.linear_equation_solver is not None: self.env.solver_environment.set_linear_equation_solver_type(config.linear_equation_solver) self.checker = None self.roots = set() self.no_calls = 0 self.time_calls = 0 self.no_splits = 0
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 test_dynasty(self): program = stormpy.parse_prism_program( "/home/simon/School/DP/synthesis/workspace/simon/die/sketch.templ") prop = "P>=1/6 [F s=7 & d=1]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.MdpParameterLiftingModelChecker() checker.specify(env, model, formulas[0].raw_formula, True) parameters = model.collect_probability_parameters() assert len(parameters) == 1 region = stormpy.pars.ParameterRegion.create_from_string( "0.1<=p0<=0.62", parameters) minr = checker.get_bound(env, region, False) maxr = checker.get_bound(env, region, True) result = checker.check_region(env, region) assert True
def test_pla_manual(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.DtmcParameterLiftingModelChecker() checker.specify(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string( "0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) result = checker.get_bound(env, region, True) assert math.isclose(float(result.constant_part()), 0.8369631383670559, rel_tol=1e-6)
def test_pla_region_valuation(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.create_region_checker(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 for par in parameters: if par.name == "pL": pL = par elif par.name == "pK": pK = par else: assert False region_valuation = dict() region_valuation[pL] = (stormpy.RationalRF(0.7), stormpy.RationalRF(0.9)) region_valuation[pK] = (stormpy.RationalRF(0.75), stormpy.RationalRF(0.95)) region = stormpy.pars.ParameterRegion(region_valuation) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLSAT region_valuation[pL] = (stormpy.RationalRF(0.4), stormpy.RationalRF(0.65)) region = stormpy.pars.ParameterRegion(region_valuation) result = checker.check_region( env, region, stormpy.pars.RegionResultHypothesis.UNKNOWN, stormpy.pars.RegionResult.UNKNOWN, True) assert result == stormpy.pars.RegionResult.EXISTSBOTH region_valuation[pK] = (stormpy.RationalRF(0.2), stormpy.RationalRF(0.715)) region_valuation[pL] = (stormpy.RationalRF(0.1), stormpy.RationalRF(0.73)) region = stormpy.pars.ParameterRegion(region_valuation) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLVIOLATED
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_pdtmc_exact_instantiation_checker(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "herman5.pm")) formulas = stormpy.parse_properties_for_prism_program( "R=? [F \"stable\"]", program) model = stormpy.build_parametric_model(program, formulas) parameters = model.collect_probability_parameters() inst_checker = stormpy.pars.PDtmcExactInstantiationChecker(model) inst_checker.specify_formula( stormpy.ParametricCheckTask(formulas[0].raw_formula, True)) inst_checker.set_graph_preserving(True) env = stormpy.Environment() point = {p: stormpy.RationalRF("1/2") for p in parameters} result = inst_checker.check(env, point) assert isinstance(result, stormpy.ExplicitExactQuantitativeCheckResult) res = result.at(model.initial_states[0]) assert isinstance(res, stormpy.Rational) assert res == stormpy.Rational("29/15")
def test_pla_bounds(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.create_region_checker(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion("0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) result = checker.get_bound(env, region, True) assert math.isclose(float(result.constant_part()), 0.8369631383670559, rel_tol=1e-6) result_vec = checker.get_bound_all_states(env, region, True) result = result_vec.at(model.initial_states[0]) assert math.isclose(result, 0.8369631383670559, rel_tol=1e-6)
def test_pla_state_bounds(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.DtmcParameterLiftingModelChecker() checker.specify(env, model, formulas[0].raw_formula, allow_model_simplification=False) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string( "0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) result_vec = checker.get_bound_all_states(env, region, True) assert len(result_vec.get_values()) == model.nr_states assert math.isclose(result_vec.at(model.initial_states[0]), 0.836963056082918, rel_tol=1e-6)
def sample(model, formula, parameters, sample_points, exact=False): """ Sample model at given points. :param model: Model. :param formula: Property. :param parameters: Parameters. :param sample_points: Sample points. :param exact: Whether exact methods should be used. :return: List of tuples (sample point, sample). """ # Prepare initial_state = model.initial_states[0] env = stormpy.Environment() inst_checker = pla_helper.init_instantiation_checker(model, formula, exact) # Sample all points samples = [] for point in sample_points: result = inst_checker.check( env, point.carl_valuation(parameters)).at(initial_state) samples.append((point, result)) logging.debug("Result for point {}: {}".format(point, result)) return samples
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_environment(self): env = stormpy.Environment()
def run(self, model, parameters, interval_parameters, properties, prob0E, prob1A, threshold, direction, options, intervals, items,model_check): """ Runs the QCQP procedure by a series of calls to gurobi. :param model: The model :type model: a stormpy dtmc/mdp :param parameters: The policy parameters occuring in the model :type parameters: a list of pycarl variables :param interval_parameters: The uncertain parameters occuring in the model :type parameters: a list of pycarl variables :param properties: The properties as an iterable over stormpy.properties :param prob0E: The states of having a probability 0 of satisfying the specification for any valuation of policies and uncertain parameters :type Prob0E: a set :param prob1A: The states of having a probability 1 of satisfying the specification for any valuation of policies and uncertain parameters :type Prob1A: a set :param threshold: The threshold :type threshold: float :param direction: Are we looking for a value below or above :type direction: a string, either "above" or "below", we assume above in this code :param options: Further options with which the algorithm should run :param intervals: List of uncertain intervals for each state and their lower and upper bounds :param items: List of uncertain intervals in the model and their lower and upper bounds :param model_check: boolean value whether we use robust model checker or not, assumed to be True :return: """ #auxillary variables for storing self._prob0E = prob0E self._prob1A = prob1A self._parameters = parameters self._interval_parameters= interval_parameters self._properties= properties self._threshold= threshold self._options= options self._intervals=intervals self._items= items self._model_check = model_check self._model= model self._mu = options.mu self._remove_set = [] assert direction in ["above", "below"] if direction == "above": raise RuntimeError("Direction == above is currently not supported.") if not options.silent: print("Number of pmc states: {}".format(model.nr_states)) print("Number of pmc transitions: {}".format(model.nr_transitions)) print("Labels: {}".format(model.labeling.get_labels())) print(model.model_type) print("Number of states: {}".format(model.nr_states)) numstate = model.nr_states #Initial solution is uniform over policies solution=dict() for x in self._parameters: solution[x]=stormpy.RationalRF(0.5) #gather the values of the interval for robust value checking regiondict=dict() print("region check") for x in self._interval_parameters: for item in items: if item.name==x.name: regiondict[x]=(stormpy.RationalRF(item.lowerbound), stormpy.RationalRF(item.upperbound)) #computes the region using stormpy region = stormpy.pars.ParameterRegion(regiondict) print(region) #creates the uncertain MC instantiator = stormpy.pars.PartialPDtmcInstantiator(model) instantiated_model = instantiator.instantiate(solution) ## creates robust verification checker env = stormpy.Environment() start_check=time.time() #robust verification steps region_checker = stormpy.pars.create_region_checker(env, instantiated_model, properties[0].raw_formula, allow_model_simplification=False) result = region_checker.get_bound_all_states(env, region, maximise=False) end_check=time.time() self.model_check_timer+=end_check-start_check #gather initial solution to the policy parameters for convexification self._paraminit = dict([[x.id, float(stormpy.RationalRF(solution[x]))] for x in parameters]) print("total model check time:",self.model_check_timer) initstate = int(model.initial_states[0]) print("model checking ans:") #initialize trust region trust_region=1.5 #gather initial solution to the probability variables from robust verification for convexification self._pinit = [threshold for _ in range(numstate)] for state in model.states: self._pinit[int(state.id)]=(result.at(state)) bestval=self._pinit[initstate] print(bestval) # The set of uncertain states robuststates1 = [] for item in intervals: stateval = int(item.state) # print(stateval,state.id) # if stateval==int(state.id): succval = int(item.successor) robuststates1.append(stateval) self._robuststates = set(robuststates1) #call the functions to build encoding self._create_encoding(model) self._set_objective(model) # add specification consraint self._encoding.addConstr(self._pVars[initstate] + self._tau[initstate] >= self._threshold) #main lpp[ for i in range(1,options.maxiter): self.iterations = i start= time.time() # build model constraints self._model_constraints(model,i) # build trust region constraints for x in parameters: self._remove_set.append(self._encoding.addConstr(self._paramVars[x.id]<=trust_region* self._paraminit[x.id])) self._remove_set.append(self._encoding.addConstr(self._paramVars[x.id]>=self._paraminit[x.id]/trust_region)) for state in model.states: self._remove_set.append(self._encoding.addConstr(self._pVars[state.id] <= trust_region * self._pinit[state.id])) self._remove_set.append(self._encoding.addConstr(self._pVars[state.id] >= self._pinit[state.id] / trust_region)) end = time.time() self.encoding_timer += (end - start) #solve the problem with Gurobi start3 = time.time() self._encoding.setObjective(self._objective, GRB.MINIMIZE) print('Solving...') self._encoding.optimize() t3 = time.time() self.solver_timer += (t3 - start3) print("Solver time :" + str(t3 - start3)) print("total solver time:",self.solver_timer) print("total encoding time:",self.encoding_timer) print("num iteration",i) # Prints the maximum violation maxx = 0 try: for state in range(numstate): val = self._tau[state].x if val > maxx: maxx = val #val = tau_neg[state].x #if val > maxx: # maxx = val if not options.silent: print("Max vio :", maxx) #print("p =", pVars[initstate].x) #gather the parameter values for policy variables parameter_values = dict([[id, param_var.x] for id, param_var in self._paramVars.items()]) #if robust model checking is allowed if model_check: #gather the solution for policy parameters solution = dict() for x in self._parameters: solution[x] = stormpy.RationalRF(parameter_values[x.id]) #create the region with uncertain parameters regiondict = dict() for x in self._interval_parameters: for item in self._items: if item.name == x.name: regiondict[x] = (stormpy.RationalRF(item.lowerbound), stormpy.RationalRF(item.upperbound)) # creates the robust model checker with storm region = stormpy.pars.ParameterRegion(regiondict) instantiator = stormpy.pars.PartialPDtmcInstantiator(model) instantiated_model = instantiator.instantiate(solution) env = stormpy.Environment() start_check = time.time() #robust model checking step 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() self.model_check_timer += end_check - start_check self._paraminit = dict([[x.id, float(stormpy.RationalRF(solution[x]))] for x in self._parameters]) print("model checking ans:") ansval=result.at(model.initial_states[0]) print(ansval) #if the solution is better than the threshold, return the solution if ansval > threshold: # TODO adjust result print("Early termination due to positive model checking result at iteration {0}: ".format(str(i))) print("p[init] = " + str(ansval) ) print("SCP parameter values: ") print("total model check time:",self.model_check_timer) self.solver_params=solution return QcqpResult(self._pVars[initstate].x, parameter_values) #if the solution is better than the best solution so far, update the probability variables and #policy parameters elif ansval>bestval: bestval=ansval (self.solver_output.append([bestval,self.model_check_timer+self.solver_timer+self.encoding_timer])) print("best found values and their computation so far") print(self.solver_output) #update the probability values for next ieration for state in model.states: self._pinit[int(state.id)] = (result.at(state)) #print(pinit) # Updares the policy parameter values for next iteration for param_id, param_var in self._paramVars.items(): if not isinstance(param_var, int): self._paraminit[param_id] = param_var.x #increase the size of trust region trust_region=min(10,(trust_region-1)*1.5+1) self.solver_params=solution #shrink the size of trust region else: trust_region=((trust_region-1)/1.5+1) self._encoding.update() #terminate if the trust region is too small if trust_region<1+1e-4: print("Early termination due to small trust region {0}: ".format(str(i))) print("p[init] = " + str(ansval)) print("SCP parameter values: ") #for id, param_var in paramVars.items(): # print(str(parameter_names[id]) + " : " + str(param_var.x)) return QcqpResult(self._pVars[initstate].x, parameter_values) print("bestval:",bestval) # if gurobi runs into numerical trouble, shrink the trust region except AttributeError: trust_region = ((trust_region - 1) / 1.5 + 1) if trust_region < 1 + 1e-4: print("Early termination due to small trust region {0}: ".format(str(i))) print("p[init] = " + str(bestval)) print("SCP parameter values: ") return QcqpResult(bestval, self._paraminit) self._encoding.update() print("total model check time:",self.model_check_timer) #if the computation time exceeds the time-out, break if self.model_check_timer+self.solver_timer+self.encoding_timer>1800: print("terminating because of time threshold") print("printing best values and seconds") for item in self.solver_output: print(item[0], item[1]) self.solver_params=solution break #remove the constraints that are convexified self._encoding.remove(self._remove_set) self._remove_set = [] self._encoding.update()
def mc_model(self, index=0, compute_action_values=False, check_dir_2=always_true): """ :param index: :param compute_action_values: :param check_dir_2: :return: """ assert len(self._formulae) > index assert not compute_action_values is_dtmc = False extract_scheduler = True if self._submodel.nr_choices == self._submodel.nr_states: is_dtmc = True self._mc_dtmc_calls += 1 extract_scheduler = False else: self._mc_mdp_calls += 1 self._mc_mdp_executions += 1 # TODO set from the outside. env = stormpy.Environment() env.solver_environment.minmax_solver_environment.precision = stormpy.Rational( 0.0000000001) # + if is_dtmc: env.solver_environment.minmax_solver_environment.method = stormpy.MinMaxMethod.policy_iteration else: env.solver_environment.minmax_solver_environment.method = stormpy.MinMaxMethod.value_iteration # assert not self._formulae[index].has_bound logger.info(f"Start checking direction 1: {self._formulae[index]}") # TODO allow qualitative model checking with scheduler extraction. prime_result = stormpy.model_checking( self._submodel, self._formulae[index], only_initial_states=False, extract_scheduler=extract_scheduler, environment=env) if is_dtmc: maximise = True absolute_min = min( [prime_result.at(x) for x in self._submodel.initial_states]) absolute_max = max( [prime_result.at(x) for x in self._submodel.initial_states]) logger.info( f"Done DTMC Checking. Result for initial state is: {absolute_min} -- {absolute_max}" ) return ExplicitMCResult(prime_result, prime_result, maximise, absolute_min=absolute_min, absolute_max=absolute_max) absolute_min = -math.inf absolute_max = math.inf second_result = None if self._formulae[ index].optimality_type == stormpy.OptimizationDirection.Maximize: maximise = True upper_result = prime_result absolute_max = max( [upper_result.at(x) for x in self._submodel.initial_states]) else: assert (self._formulae[index].optimality_type == stormpy.OptimizationDirection.Minimize) maximise = False lower_result = prime_result absolute_min = min( [lower_result.at(x) for x in self._submodel.initial_states]) if check_dir_2(absolute_min, absolute_max): self._mc_mdp_executions += 1 logger.info( f"Start checking direction 2: {self._alt_formulae[index]}") second_result = stormpy.model_checking( self._submodel, self._alt_formulae[index], only_initial_states=False, extract_scheduler=extract_scheduler, environment=env) if maximise: lower_result = second_result absolute_min = min([ lower_result.at(x) for x in self._submodel.initial_states ]) else: assert not maximise upper_result = second_result absolute_max = max([ upper_result.at(x) for x in self._submodel.initial_states ]) logger.info( f"Done Checking. Result for initial state is: {absolute_min} -- {absolute_max}" ) return ExplicitMCResult(prime_result, second_result, maximise, absolute_min=absolute_min, absolute_max=absolute_max)