def test_change_parametric_matrix_modelchecking(self): import stormpy.logic program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) model = stormpy.build_parametric_model(program, formulas) initial_state = model.initial_states[0] assert initial_state == 0 matrix = model.transition_matrix # Check matrix one_pol = stormpy.RationalRF(1) one_pol = stormpy.FactorizedPolynomial(one_pol) one = stormpy.FactorizedRationalFunction(one_pol, one_pol) for e in matrix: assert e.value() == one or len(e.value().gather_variables()) > 0 # First model checking result = stormpy.model_checking(model, formulas[0]) ratFunc = result.at(initial_state) assert len(ratFunc.gather_variables()) > 0 # Change probabilities two_pol = stormpy.RationalRF(2) two_pol = stormpy.FactorizedPolynomial(two_pol) new_val = stormpy.FactorizedRationalFunction(one_pol, two_pol) for e in matrix: if len(e.value().gather_variables()) > 0: e.set_value(new_val) for e in matrix: assert e.value() == new_val or e.value() == one # Second model checking result = stormpy.model_checking(model, formulas[0]) ratFunc = result.at(initial_state) assert len(ratFunc.gather_variables()) == 0
def test_parametric_matrix_from_numpy_row_grouping(self): import numpy as np one_pol = stormpy.RationalRF(1) one_pol = stormpy.FactorizedPolynomial(one_pol) first_val = stormpy.FactorizedRationalFunction(one_pol, one_pol) two_pol = stormpy.RationalRF(2) two_pol = stormpy.FactorizedPolynomial(two_pol) sec_val = stormpy.FactorizedRationalFunction(two_pol, two_pol) third_val = stormpy.FactorizedRationalFunction(one_pol, two_pol) array = np.array([[sec_val, first_val], [first_val, sec_val], [sec_val, sec_val], [third_val, third_val]]) matrix = stormpy.build_parametric_sparse_matrix( array, row_group_indices=[1, 3]) # Check matrix dimension assert matrix.nr_rows == array.shape[0] assert matrix.nr_columns == array.shape[1] assert matrix.nr_entries == 8 # Check matrix values for r in range(array.shape[1]): row = matrix.get_row(r) for e in row: assert (e.value() == array[r, e.column]) # Check row groups assert matrix.get_row_group_start(0) == 1 assert matrix.get_row_group_end(0) == 3 assert matrix.get_row_group_start(1) == 3 assert matrix.get_row_group_end(1) == 4
def storm_region(self, variables): assert len(variables) == len(self.intervals) region = dict() for var in variables: interval = self.intervals[var.name] region[var] = (stormpy.RationalRF(interval.lower), stormpy.RationalRF(interval.upper)) return stormpy.pars.ParameterRegion(region)
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 path = stormpy.examples.files.prism_pdtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=3]" properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) model = stormpy.build_parametric_model(prism_program, properties) print("Model supports parameters: {}".format(model.supports_parameters)) parameters = model.collect_probability_parameters() assert len(parameters) == 2 instantiator = stormpy.pars.PDtmcInstantiator(model) point = dict() for x in parameters: print(x.name) point[x] = stormpy.RationalRF(0.0) instantiated_model = instantiator.instantiate(point) result = stormpy.model_checking(instantiated_model, properties[0]) print(result)
def test_instantiate_dft(self): pycarl.clear_pools() dft = stormpy.dft.load_parametric_dft_galileo_file( get_example_path("dft", "symmetry_param.dft")) assert dft.nr_elements() == 7 assert dft.nr_be() == 4 instantiator = stormpy.dft.DFTInstantiator(dft) x = pycarl.variable_with_name("x") y = pycarl.variable_with_name("y") valuation = {x: stormpy.RationalRF("5"), y: stormpy.RationalRF("0.01")} inst_dft = instantiator.instantiate(valuation) assert inst_dft.nr_elements() == 7 assert inst_dft.nr_be() == 4 elem = inst_dft.get_element_by_name("C") assert str(elem) == "{C} BE exp(5, 0.05)" elem = inst_dft.get_element_by_name("D") assert str(elem) == "{D} BE exp(0.01, 0)"
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 test_instantiate_dtmc(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) model = stormpy.build_parametric_model(program, formulas) parameters = model.collect_probability_parameters() assert len(parameters) == 2 instantiator = stormpy.pars.ModelInstantiator(model) point = {p: stormpy.RationalRF("0.4") for p in parameters} instantiated_model = instantiator.instantiate(point) assert instantiated_model.nr_states == model.nr_states assert not instantiated_model.has_parameters assert "0.4" in str(instantiated_model.transition_matrix[1]) point = {p: stormpy.RationalRF("0.5") for p in parameters} instantiated_model2 = instantiator.instantiate(point) assert "0.5" in str(instantiated_model2.transition_matrix[1])
def test_parametric_matrix_builder(self): builder = stormpy.ParametricSparseMatrixBuilder(force_dimensions=True) matrix = builder.build() assert matrix.nr_columns == 0 assert matrix.nr_rows == 0 assert matrix.nr_entries == 0 builder_5x5 = stormpy.ParametricSparseMatrixBuilder( 5, 5, force_dimensions=False) one_pol = stormpy.RationalRF(1) one_pol = stormpy.FactorizedPolynomial(one_pol) first_val = stormpy.FactorizedRationalFunction(one_pol) two_pol = stormpy.RationalRF(2) two_pol = stormpy.FactorizedPolynomial(two_pol) sec_val = stormpy.FactorizedRationalFunction(two_pol) builder_5x5.add_next_value(0, 0, first_val) builder_5x5.add_next_value(0, 1, first_val) builder_5x5.add_next_value(2, 2, sec_val) builder_5x5.add_next_value(2, 3, sec_val) assert builder_5x5.get_last_column() == 3 assert builder_5x5.get_last_row() == 2 builder_5x5.add_next_value(3, 2, sec_val) builder_5x5.add_next_value(3, 4, sec_val) builder_5x5.add_next_value(4, 3, sec_val) matrix_5x5 = builder_5x5.build() assert matrix_5x5.nr_columns == 5 assert matrix_5x5.nr_rows == 5 assert matrix_5x5.nr_entries == 7 for e in matrix_5x5: assert (e.value() == first_val and e.column < 2) or (e.value() == sec_val and e.column > 1)
def test_parametric_matrix_replace_columns(self): builder = stormpy.ParametricSparseMatrixBuilder(3, 4, force_dimensions=False) one_pol = stormpy.RationalRF(1) one_pol = stormpy.FactorizedPolynomial(one_pol) first_val = stormpy.FactorizedRationalFunction(one_pol, one_pol) two_pol = stormpy.RationalRF(2) two_pol = stormpy.FactorizedPolynomial(two_pol) sec_val = stormpy.FactorizedRationalFunction(two_pol, two_pol) third_val = stormpy.FactorizedRationalFunction(one_pol, two_pol) builder.add_next_value(0, 1, first_val) builder.add_next_value(0, 2, sec_val) builder.add_next_value(0, 3, third_val) builder.add_next_value(1, 1, first_val) builder.add_next_value(1, 2, sec_val) builder.add_next_value(1, 3, third_val) builder.add_next_value(2, 1, first_val) builder.add_next_value(2, 2, sec_val) builder.add_next_value(2, 3, third_val) # replace rows builder.replace_columns([3, 2], 2) matrix = builder.build() assert matrix.nr_entries == 9 # Check if columns where replaced for e in matrix: assert (e.value() == first_val and e.column == 1) or ( e.value() == third_val and e.column == 2) or (e.value() == sec_val and e.column == 3)
def test_parametric_model_checking_sparse(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.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters initial_state = model.initial_states[0] assert initial_state == 0 result = stormpy.model_checking(model, formulas[0]) func = result.at(initial_state) one = stormpy.FactorizedPolynomial(stormpy.RationalRF(1)) assert func.denominator == one
def test_parametric_transitions(self): program = stormpy.parse_prism_program( get_example_path("pmdp", "two_dice.nm")) model = stormpy.build_parametric_model(program) assert model.states[1].id == 1 one = stormpy.FactorizedPolynomial(stormpy.RationalRF(1)) i = 0 for state in model.states: assert state.id == i i += 1 j = 0 for action in state.actions: assert j == 0 or j == 1 j += 1 for transition in action.transitions: assert transition.value().denominator == one
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_region(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) 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) assert region.area == stormpy.RationalRF(1) / stormpy.RationalRF(25) for par in parameters: if par.name == "pL": pL = par elif par.name == "pK": pK = par else: assert False dec = stormpy.RationalRF(100) region_valuation = {pL: (stormpy.RationalRF(70) / dec, stormpy.RationalRF(90) / dec), pK: (stormpy.RationalRF(75) / dec, stormpy.RationalRF(95) / dec)} region = stormpy.pars.ParameterRegion(region_valuation) assert region.area == stormpy.RationalRF(1) / stormpy.RationalRF(25)
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 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 carl_valuation(self, variables): assert len(variables) == len(self.val) valuation = dict() for var in variables: valuation[var] = stormpy.RationalRF(self.val[var.name]) return valuation