def __init__(self):
self.manager_params = {
"隐藏层神经元个数": 5,
"训练样本取样数": 6000,
"学习速率": 0.05,
"矫正率": 0.1
}
self._params_map = {
"nh": "隐藏层神经元个数",
"samples": "训练样本取样数",
"learning_rate": "学习速率",
"correct_rate": "矫正率"
}
self.mdl_parser = ModelConstructor()
self.model = None
self.expr_params = list() # [(name, val_list)]
self.ltl = None
self.checker = None
self.regressor = BPNN()
self.test_xs = [] # [(vals)]
self.ltl_parser = LTLParser().build_parser()
self.predict_xs = None
self.predict_ys = None
self.prism_test_datas = []
def test():
# get model object
constructor = Constructor()
model_file_path = "../../prism_model/smalltest.prism"
constructor._parse(model_file_path)
model = constructor.model
# set day's value
days = range(1, 365*5)
# 运用parsed function计算出的结果
parsed_prbs = []
# 运用模型中的数据计算出的真实的结果
prbs = [] # [(sb_fail_prb, s3r_fail_prb)]
for day_val in days:
# compute the failure probability of modules
# get the fail prob function and compute
var_day = model.getLocalVar("day")
var_day.set_value(day_val)
prbs.append(fail_prob_of_model(model, constructor._parser.vfmap))
# get the parsed function and use it to compute the failure probability
f_sb = constructor._parser.vfmap["sb_fail_prob"]
f_s3r = constructor._parser.vfmap["s3r_fail_prob"]
parsed_prbs.append((f_sb(), f_s3r()))
# compare
assert len(prbs) == len(parsed_prbs)
for tuple1, tuple2 in zip(prbs, parsed_prbs):
f1, f2 = tuple1
f3, f4 = tuple2
precision = 1e-8
# logger.info("f1={}, f3={}".format(f1, f3))
# logger.info("f2={}, f4={}".format(f2, f4))
assert fabs(f1 - f3) < precision, "day={}, f1={}, f3={}".format(day_val, f1, f3)
assert fabs(f2 - f4) < precision, "day={}, f2={}, f4={}".format(day_val, f2, f4)
def setUp(self):
filepath = get_prism_model_dir() + get_sep() + "smalltest.prism"
self.model_constructor = ModelConstructor()
self.model = self.model_constructor._parse(filepath)
self.duration = 180
self.model.duration = self.duration
ltl = "true U<={} failure".format(self.duration)
parsed = LTLParser().build_parser().parse_line(ltl)
self.checker = Checker(model=self.model, ltl=parsed)
class Manager(object):
def __init__(self):
self.mdl_parser = ModelConstructor()
self.model = None
def input_file(self, file_path):
self.model = self.mdl_parser.parseModelFile(file_path)
def __init__(self, model_path, ltl, path_length, params, checking_delta=0.01, prism_data_path=None):
'''
:param model_path:
:param ltl:
:param path_length:
:param params: value of unsure parameters: map with key to be param_name, value to be value list
:param prism_data_path:
'''
unittest.TestCase.__init__(self)
# todo check path exist and is a file
self.model_path = model_path
self.prism_data_path = prism_data_path
self.ltl = ltl
self.parsed_ltl = None
self.modelConstructor = ModelConstructor()
self.ltl_parser = LTLParser().build_parser()
self.duration = path_length
self.checking_delta = checking_delta
self.params = params
def setUp(self):
self._constructor = ModelConstructor()
self._ltl_parser = LTLParser()
self.logger = logging.getLogger(__name__)
self.logger.addHandler(sys.stdout)
self.logger.setLevel(logging.INFO)
if not isdir(get_prism_model_dir()):
raise Exception("model root path not exist: {}".format(
get_prism_model_dir()))
self._constructor.set_base_dir(self._get_model_root_path())
model_path = self._get_model_root_path() + get_sep(
) + self._get_model_name() + self.PRISM_SUFFIX
if not isfile(model_path):
raise Exception("Model file {} not exist".format(model_path))
self._renaming_helper = RenamingHelper(model_path)
self._renaming_helper.rewrite()
rewritten_path = self._renaming_helper.export()
filename = basename(rewritten_path)
filename = splitext(filename)[0]
self._model = self._constructor.parse(filename)
self._param_map = {}
class ModelFactory(object):
module_factory = ModuleFactory(SPSConfig())
model_constructor = ModelConstructor()
@classmethod
def get_built(cls):
def failurecondition(vs, cs):
sb_status = vs['sb_status'].get_value()
s3r_status = vs['s3r_status'].get_value()
bcr_status = vs['bcr_status'].get_value()
bdr_status = vs['bdr_status'].get_value()
return (sb_status + s3r_status + bcr_status + bdr_status) < 4
labels = {}
labels['failure'] = failurecondition
model = ModulesFile(ModelType.DTMC,
failureCondition=failurecondition,
stopCondition=failurecondition,
modules=[
cls.module_factory.timermodule(),
cls.module_factory.s3rmodule(),
cls.module_factory.sbmodule(),
cls.module_factory.bcrmodule(),
cls.module_factory.bdrmodule()
],
labels=labels)
model._constants[
'SCREEN_THICKNESS'] = cls.module_factory.config.getParam(
'SCREEN_THICKNESS')
model.duration = 730
return model
@classmethod
def setParam(cls, name, value):
if name not in cls.module_factory.config.params.keys():
return
cls.module_factory.config.setParam(name, value)
@classmethod
def get_parsed(cls, duration=730):
sep = get_sep()
mdl_dir = sep.join((get_proj_dir(), 'prism_model', 'smalltest.prism'))
model = cls.model_constructor._parse(mdl_dir)
model.duration = duration
return model
class DTMCSyncUnittest(unittest.TestCase):
def setUp(self):
filepath = get_prism_model_dir() + get_sep() + "smalltest.prism"
self.model_constructor = ModelConstructor()
self.model = self.model_constructor._parse(filepath)
self.duration = 180
self.model.duration = self.duration
ltl = "true U<={} failure".format(self.duration)
parsed = LTLParser().build_parser().parse_line(ltl)
self.checker = Checker(model=self.model, ltl=parsed)
def test_parsing(self):
self.assertEqual(self.model.model_type, ModelType.DTMC)
def test_gen_path(self):
# 测试生成路径的正确性
# 生成的路径要么总长为duration,要么出现failure
for _ in range(5000):
path = self.model.get_random_path_V2()
for step in path:
logger.info(step)
logger.info("----------------")
if {"failure"} in [step.ap_set for step in path]:
continue
passed_time = path[-1].next_move.passed_time + \
path[-1].next_move.holding_time
if int(passed_time) < self.duration:
for step in path:
logger.error(step)
logger.error("-------------")
def test_checking(self):
thickness_vals = range(1, 10, 1)
constant_objs = [Constant("SCREEN_THICKNESS", v)
for v in thickness_vals]
for obj in constant_objs:
self.model_constructor._parser.vcf_map[obj.get_name()].set_value(
obj.get_value())
self.model.commPrepared = False
logger.info(
"param={}, checker's result={}".format(
obj.get_value(),
self.checker.run_checker()))
def dpm_regress():
'''
证明回归分析的结果和prism的误差和SMC和prism的误差相差不大，
即证明回归分析可以代替SMC
:return: null
'''
from PathHelper import get_prism_model_dir
from checker.Checker import Checker
from compiler.LTLParser import LTLParser
from util.util import interval
from experiment.ExperimentWrapper import ExperimentWrapper
base_dir = get_prism_model_dir()
model = ModelConstructor(base_dir).parse("smalltest")
ltl = "true U<=180 failure"
ltl_parser = LTLParser().build_parser()
parsed_ltl = ltl_parser.parse_line(ltl)
checker = Checker(model, parsed_ltl, duration=180)
expe_executor = ExperimentWrapper(checker, samples_per_param=600)
train_xs = interval(1, 10, 0.3)
def get_parsed(self):
constructor = ModelConstructor()
model = constructor.parseModelFile("../../prism_model/smalltest.prism")
return model
def get_parsed():
sep = get_sep()
mdl_dir = sep.join((get_proj_dir(), 'prism_model', 'smalltest.prism'))
return ModelConstructor().parseModelFile(mdl_dir)
from compiler.PRISMParser import ModelConstructor constructor = ModelConstructor() mdl_fl_path = "../../prism_model/smalltest.prism" model = constructor._parse(mdl_fl_path) assert model.labels["failure"]() is False model.localVars["sb_status"].set_value(0) assert model.labels["failure"]() is True
class ModelTestBase(unittest.TestCase):
PRISM_SUFFIX = ".prism"
def setUp(self):
self._constructor = ModelConstructor()
self._ltl_parser = LTLParser()
self.logger = logging.getLogger(__name__)
self.logger.addHandler(sys.stdout)
self.logger.setLevel(logging.INFO)
if not isdir(get_prism_model_dir()):
raise Exception("model root path not exist: {}".format(
get_prism_model_dir()))
self._constructor.set_base_dir(self._get_model_root_path())
model_path = self._get_model_root_path() + get_sep(
) + self._get_model_name() + self.PRISM_SUFFIX
if not isfile(model_path):
raise Exception("Model file {} not exist".format(model_path))
self._renaming_helper = RenamingHelper(model_path)
self._renaming_helper.rewrite()
rewritten_path = self._renaming_helper.export()
filename = basename(rewritten_path)
filename = splitext(filename)[0]
self._model = self._constructor.parse(filename)
self._param_map = {}
def _get_model_name(self):
'''
return the name of model file(extension not included)
supposed to be implemented by subclass
:return: string
'''
pass
def _get_model_root_path(self):
'''
could be overrided if necessary
:return:
'''
return get_prism_model_dir()
def _set_parameters(self, name, values):
'''
store parameters in this object
:param name: parameter name
:param values: list of value
:return:
'''
self._param_map[name] = values
def _set_parameter(self, k, v):
'''
设置参数到_checker._constants
:param k: parameter name
:param v: parameter value
:return:
'''
self._model.set_constant(k, v)
def get_model(self):
return self._model
def buildCommand():
constructor = Constructor()
model = constructor._parse("../../prism_model/CommandTest.prism")
return model.modules.values()[0].commands.values()[0]
class Manager(object):
def __init__(self):
self.manager_params = {
"隐藏层神经元个数": 5,
"训练样本取样数": 6000,
"学习速率": 0.05,
"矫正率": 0.1
}
self._params_map = {
"nh": "隐藏层神经元个数",
"samples": "训练样本取样数",
"learning_rate": "学习速率",
"correct_rate": "矫正率"
}
self.mdl_parser = ModelConstructor()
self.model = None
self.expr_params = list() # [(name, val_list)]
self.ltl = None
self.checker = None
self.regressor = BPNN()
self.test_xs = [] # [(vals)]
self.ltl_parser = LTLParser().build_parser()
self.predict_xs = None
self.predict_ys = None
self.prism_test_datas = []
def set_manager_param(self, name, param):
self.manager_params[name] = param
def set_manager_param_simple(self, name, value):
if name not in self._params_map.keys():
# todo system-level logger
pass
self.manager_params[self._params_map[name]] = value
def get_manager_param(self, name):
if name not in self._params_map.keys():
print "key not exist when get manager parameter: {}".format(name)
return self.manager_params[self._params_map[name]]
def set_random_path_duration(self, duration):
self.set_manager_param("duration", duration)
self.model.duration = duration
def read_model_file(self, file_path):
self.model = self.mdl_parser._parse(file_path)
self.checker = Checker(model=self.model)
def _set_constants(self, *constants):
'''constants: ([constant_obj])'''
while len(self.expr_params):
self.expr_params.pop(0)
self.expr_params.extend(constants)
def set_train_constants(self, *constants):
'''设置训练时需要的参数
constant: (name, val_list)
'''
self.expr_params = constants
def set_ltl(self, ltl):
if self.checker:
self.checker.ltl = ltl
return ltl
else:
return
def set_model_duration(self, str_duration):
'''duration: str_valued duration'''
if self.model.model_type == ModelType.DTMC:
self.model.duration = int(str_duration)
else:
# CTMC case
self.model.duration = float(str_duration)
def _set_param(self, *constants):
'''
将参数设置到ModulesFile中
:param constants: [constant_obj]
:return: None
'''
model = self.checker.model
if model:
for constant_obj in constants:
model.set_constant(constant_obj)
def _clear_param(self, *constants):
for constant_obj in constants:
self.mdl_parser._parser.vcf_map[constant_obj.get_name()].set_value(
None)
def set_test_xs(self, test_xs):
'''
设置回归分析时参数的值
:param test_xs: [(param1_value, param2_val, ...)]
:return: None
'''
self.test_xs = test_xs
def _to_constant_objs(self):
'''
将self.expr_params转化为[[constant_obj]]
:return: [[constant_obj]]
'''
result = []
for n, vl in self.expr_params:
objs = []
for v in vl:
objs.append(Constant(n, v))
result.append(objs)
return result
def train_network(self):
'''给定参数，先在checker中跑，得到训练参数上的ltl公式验证结果(train_y)，然后用这些数据对神经网络进行训练'''
train_data_x = []
train_data_y = []
constant_objs = self._to_constant_objs()
self.checker.samples = self.get_manager_param("samples")
for constant_list in itertools.product(*constant_objs):
try:
self._set_param(*constant_list)
self.model.prepare()
train_y = self.checker.run_checker()
train_x = [c_obj.get_value() for c_obj in constant_list]
train_data_x.append(train_x)
train_data_y.append(train_y)
finally:
self._clear_param(*constant_list)
self.regressor.setup(len(self.expr_params),
int(self.get_manager_param("nh")), 1,
self.get_manager_param("learning_rate"),
self.get_manager_param("correct_rate"))
print train_data_x
print train_data_y
self.regressor.train(train_data_x, train_data_y)
# dump the network
network_obj = self.regressor
dump_file = "nn.txt"
try:
f = open(dump_file, "wb")
pickle.dump(network_obj, f)
f.close()
except IOError:
print "IOError when dumping network object. Please check your access permission"
def compute_error(self, err_func, values1, values2):
# param of red_func: val1, val2)计算val1和val2之间的误差，并将所有的误差相加
errors = sum(map(err_func, [t for t in zip(values1, values2)]))
return errors
def run_test(self):
'''对给定测试参数运行神经网络进行预测'''
# try loading dumped network
if os.path.exists("nn.txt") and os.access("nn.txt", os.R_OK):
f = open("nn.txt", "rb")
network_obj = pickle.load(f)
if network_obj:
self.regressor = network_obj
f.close()
test_xs = self.test_xs # [(vals)]
test_expr_ys = []
for test_x in test_xs:
results = self.regressor.predict(list(test_x))
# results is of length 1
test_expr_ys.append(results[0])
print "Predict results: "
for (x, y) in zip(test_xs, test_expr_ys):
print "x={}, predict={}".format(x, y)
return test_expr_ys
def unsure_param_names(self):
return self.mdl_parser._parser.unsure_parameters()
def plot_expr_datas(self, expr_xs, expr_ys, true_ys=None):
if true_ys:
plot_multi((expr_xs, expr_ys, "predict"),
(expr_xs, true_ys, "prism"))
else:
param = (expr_xs, expr_ys, "predict")
plot_multi(param)
def save_predict_results(self, xs, ys):
assert len(ys) == len(xs)
self.predict_xs = xs
self.predict_ys = ys
def __init__(self):
self.mdl_parser = ModelConstructor()
self.model = None
class ParserTest(unittest.TestCase):
'''
单元测试：测试parser出的模型运转良好
'''
def __init__(self, model_path, ltl, path_length, params, checking_delta=0.01, prism_data_path=None):
'''
:param model_path:
:param ltl:
:param path_length:
:param params: value of unsure parameters: map with key to be param_name, value to be value list
:param prism_data_path:
'''
unittest.TestCase.__init__(self)
# todo check path exist and is a file
self.model_path = model_path
self.prism_data_path = prism_data_path
self.ltl = ltl
self.parsed_ltl = None
self.modelConstructor = ModelConstructor()
self.ltl_parser = LTLParser().build_parser()
self.duration = path_length
self.checking_delta = checking_delta
self.params = params
def setUp(self):
self.model = self.modelConstructor._parse(self.model_path)
self.parsed_ltl = self.ltl_parser.parse_line(self.ltl)
if self.prism_data_path:
self.prism_data_rows = parse_csv_rows(self.prism_data_path)
if self.prism_data_rows:
self.prism_data_map = {}
for row in self.prism_data_rows:
attr = row[:-1]
label = row[-1]
self.prism_data_map[tuple(attr)] = label
checker = Checker(self.model, self.parsed_ltl, duration=self.duration)
self.experiment_wrapper = ExperimentWrapper(checker, self.params)
self.logger = logging.getLogger(__name__)
self.logger.addHandler(logging.StreamHandler(sys.stdout))
self.logger.setLevel(logging.DEBUG)
def testChecking(self):
'''
verify the difference between smc and provided prism_data is within checking_delta
:return: None
'''
checked_result_map = {}
for name, values in self.params.items():
self.model.commPrepared = False
constant_obj = Constant(name, )
set_result = self.model.set_constant(constant_obj)
assert set_result
result = self.checker.run_checker()
checked_result_map[thickness] = result
error_map = {}
self.logger.info("check result: %s", str(checked_result_map))
for k, v in checked_result_map.items():
error_map[float(k)] = fabs(v - self.prism_data_map[float(k)])
self.logger.info("error_map: %s", str(error_map))
self.assertGreaterEqual(0.01, sum(error_map.values()) / len(checked_result_map))
def testGenRandomPath(self):
'''
验证model产生的随机路径的长度要么等于duration，要么其中包含failure状态
:return: None
'''
self.model.set_constant_name_value(self.PARAM_NAME, self.thicknesses[4])
genCnt = 0
while True:
genCnt += 1
self.logger.info("genCnt = %d", genCnt)
path = self.model.get_random_path_V2()
ap_sets = [step.ap_set for step in path]
ap_set = reduce(lambda set1, set2: set1.union(set2), ap_sets)
if len(path) == self.duration:
if "failure" not in ap_set:
self.assertFalse(self.checker.verify(path))
else:
self.assertTrue(self.checker.verify(path))
continue
elif "failure" in ap_set:
self.assertTrue(self.checker.verify(path))
else:
break
from compiler.PRISMParser import ModelConstructor constructor = ModelConstructor() mdl_fl_path = "../../prism_model/smalltest.prism" model = constructor.parseModelFile(mdl_fl_path) assert model.labels["failure"]() is False model.localVars["sb_status"].setValue(0) assert model.labels["failure"]() is True
def get_parsed():
constructor = ModelConstructor()
model = constructor._parse("../../prism_model/smalltest.prism")
return model
