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)
