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
