class CheckerUnittest(TestCase): def setUp(self): self._checker = Checker(None) self.parsed_ltl1 = ["U[1, 2]", "true", "ap1"] self.parsed_ltl2 = ["U[2, 2]", "true", "ap1"] self.parsed_ltl3 = ["U[3, 3]", "true", "ap1"] self.parsed_ltl4 = ["U[0.001, 0.001]", "true", "ap1"] self.parsed_ltl5 = ["U[0.002, 0.002]", "true", "ap1"] self.parsed_ltl6 = ["U[0.003, 0.003]", "true", "ap1"] apsets = [{"a"}, {"ap1"}] next_moves = [ NextMove(0, 1, None, 1.0, 1.0), NextMove(1, 1, None, 1.0, 1.0) ] next_moves1 = [ NextMove(0.0, 0.001, None, 1.0, 1.0), NextMove(0.001, 0.001, None, 1.0, 1.0) ] self.path = [Step(apset, move) for apset, move in zip(apsets, next_moves)] self.path1 = [Step(_apset, _move) for _apset, _move in zip(apsets, next_moves1)] def testCheckUntil(self): self.assertTrue(self._checker.verify(self.path, self.parsed_ltl1)) self.assertTrue(self._checker.verify(self.path, self.parsed_ltl2)) self.assertFalse(self._checker.verify(self.path, self.parsed_ltl3)) self.assertTrue(self._checker.verify(self.path1, self.parsed_ltl4)) self.assertTrue(self._checker.verify(self.path1, self.parsed_ltl5)) self.assertFalse(self._checker.verify(self.path1, self.parsed_ltl6))
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 setUp(self): self.manager = Manager() filepath = get_prism_model_dir() + get_sep() + "DPM.prism" self.manager.read_model_file(filepath) self.model = self.manager.model ltl = "true U<=10 failure" parsed_ltl = LTLParser().build_parser().parse_line(ltl) self.manager.set_manager_param_simple("duration", 10.0) self.checker = Checker(model=self.model, ltl=parsed_ltl, duration=10.0) self.manager.set_ltl(parsed_ltl) self.prism_x, self.prism_y = parse_csv_cols(get_prism_model_dir() + get_sep() + "Q_TRIGGER_1_20_1.csv")
def testSPS(): from util.util import interval from module.Module import Constant config = SPSConfig.SPSConfig() moduleFactory = ModuleFactory(config) modelfactory = ModelFactory(moduleFactory) model = modelfactory.get_built() ltl = ['U[1, {0}]'.format(730), 'T', 'failure'] # 一年之内系统失效 checker = Checker(model, ltl, duration=730, fb=False) wrapper = ExperimentWrapper(checker, samples_per_param=100) trainx = interval(1, 10, 0.5) testx = interval(1, 10, 0.1) thickness_params = [Constant('SCREEN_THICKNESS', st) for st in trainx] wrapper.setconstants([thickness_params]) result = wrapper.do_expe() cases = map(lambda tuple: tuple[0], result) labels = map(lambda tuple: tuple[1], result) regressor = BPNeuralNetwork() regressor.setup(1, 5, 1) regressor.train(cases, labels) test_cases = map(lambda c: Constant('SCREEN_THICKNESS', c), testx) test_labels = [regressor.predict(test_case) for test_case in testx] # 对多组参数进行模型验证 # logger.info("mc begin") # wrapper.setconstants([test_cases]) # mcresult = wrapper.modelcheck() # mc_labels = map(lambda tuple: tuple[1], mcresult) plt.plot(testx, [i[0] for i in test_labels], label='predict') # plt.plot(map(lambda const: const.get_value(), test_cases), mc_labels, label='mc') plt.show()
def setUp(self): ModelTestBase.setUp(self) self._parsed_ltl = self._ltl_parser.parse_line(self._get_ltl()) self._duration = str2num(self._ltl_parser.parse_duration(self._get_ltl())) if self._duration is None: self._duration = self._get_duration() self._checker = Checker(self._model, self._parsed_ltl, self._duration, self._get_sample_size())
def do_expr_parsed(): model = ModelFactory.get_parsed() checker = Checker(model=model, ltl=ltl, duration=TIME_LIMIT_IN_DAYS*2) # wrapper = ExperimentWrapper(checker, samples_per_param=SAMPLES_PER_PARAM) wrapper = ExperimentWrapper(checker) wrapper.setconstants([thickness_cnsts,]) logger.info("Parsed model expr began.") result = wrapper.do_expe() logger.info("Parsed model expr end.") return result
def setUp(self): self._checker = Checker(None) self.parsed_ltl1 = ["U[1, 2]", "true", "ap1"] self.parsed_ltl2 = ["U[2, 2]", "true", "ap1"] self.parsed_ltl3 = ["U[3, 3]", "true", "ap1"] self.parsed_ltl4 = ["U[0.001, 0.001]", "true", "ap1"] self.parsed_ltl5 = ["U[0.002, 0.002]", "true", "ap1"] self.parsed_ltl6 = ["U[0.003, 0.003]", "true", "ap1"] apsets = [{"a"}, {"ap1"}] next_moves = [ NextMove(0, 1, None, 1.0, 1.0), NextMove(1, 1, None, 1.0, 1.0) ] next_moves1 = [ NextMove(0.0, 0.001, None, 1.0, 1.0), NextMove(0.001, 0.001, None, 1.0, 1.0) ] self.path = [Step(apset, move) for apset, move in zip(apsets, next_moves)] self.path1 = [Step(_apset, _move) for _apset, _move in zip(apsets, next_moves1)]
def stdmode(self): IO.writestr('Judger Identifier: {id}'.format( id=Config.getValue('configs/global.json', 'identifier'))) IO.writestr('Simulation Tool: {sim}'.format(sim=self.task['tool'])) IO.writestr(' - Standard Mode - ') runner = self.runner_type(self.task['src'], self.path) r = runner.compile() if not r: IO.writestr('Compile Error') return for test in self.testcaseSet: if not test.display: IO.writestr( '# Test Case #<{name}>: Omitted\nComment: Standard Answer not ready.' .format(name=test.name)) continue outstr = 'Test Case #<{name}>: '.format(name=test.name) r = runner.run(test, 'out.txt') if not r: outstr += "{res} \nComment: {comment}".format( res='Runtime Error', comment='Runtime Error') IO.writestr(outstr) break Checker.timetrim(test.path + '/' + test.display, self.path + '/out/std_t.txt') Checker.timetrim(self.path + '/out/out.txt', self.path + '/out/out_t.txt') # res = Checker.check(test.path + '/' + test.display, self.path + '/out/out.txt') res = Checker.check(self.path + '/out/std_t.txt', self.path + '/out/out_t.txt') outstr = 'Test Case #<{name}>: '.format(name=test.name) if res == None: outstr += 'Checker Error' else: outstr += "{res} \nComment: {comment}".format(res=res[0], comment=res[1]) IO.writestr(outstr)
def patmode(self): IO.writestr('Judger Identifier: {id}'.format( id=Config.getValue('configs/global.json', 'identifier'))) IO.writestr('Simulation Tool: {sim}'.format(sim=self.task['tool'])) IO.writestr(' - Pat Mode - ') runner1 = self.runner_type(self.task['src1'], self.path) r = runner1.compile() if not r: IO.writestr('src1 Compile Error') return runner2 = self.runner_type(self.task['src2'], self.path) r = runner2.compile() if not r: IO.writestr('src2 Compile Error') return for test in self.testcaseSet: outstr = 'Test Case #<{name}>: '.format(name=test.name) r = runner1.run(test, 'out1.txt') if not r: outstr += "{res} \nComment: {comment}".format( res='Runtime Error', comment='src1 Runtime Error') r = runner2.run(test, 'out2.txt') if not r: outstr += "{res} \nComment: {comment}".format( res='Runtime Error', comment='src2 Runtime Error') Checker.timetrim(self.path + '/out/out1.txt', self.path + '/out/out1_t.txt') Checker.timetrim(self.path + '/out/out2.txt', self.path + '/out/out2_t.txt') res = Checker.check(self.path + '/out/out1_t.txt', self.path + '/out/out2_t.txt') if res == None: outstr += 'Checker Error' else: outstr += "{res} \nComment: {comment}".format(res=res[0], comment=res[1]) IO.writestr(outstr)
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)
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_checker(model): # built = ModelFactory.get_built() ltl = ["U[1, {}]".format(int(DURATION)), "T", "failure"] checker = Checker(model=model, ltl=ltl, duration=DURATION, c=c, d=d) return checker
class TestSyncCommands(unittest.TestCase): def setUp(self): self.manager = Manager() filepath = get_prism_model_dir() + get_sep() + "DPM.prism" self.manager.read_model_file(filepath) self.model = self.manager.model ltl = "true U<=10 failure" parsed_ltl = LTLParser().build_parser().parse_line(ltl) self.manager.set_manager_param_simple("duration", 10.0) self.checker = Checker(model=self.model, ltl=parsed_ltl, duration=10.0) self.manager.set_ltl(parsed_ltl) self.prism_x, self.prism_y = parse_csv_cols(get_prism_model_dir() + get_sep() + "Q_TRIGGER_1_20_1.csv") def test_parsing(self): # 测试解析成功 self.assertEqual(self.model.model_type, ModelType.CTMC) logger.info("parsed commands") for module in self.model.modules.values(): for comms in module.commands.values(): if isinstance(comms, list): for comm in comms: logger.info("comm {} from module {}".format( comm.name, module.name)) else: logger.info("comm {} from module {}".format( comm.name, module.name)) def test_gen_path(self): # 测试生成路径的正确性 # 生成的路径要么总长为duration,要么出现failure failure_cnt = 0 for _ in range(5000): self.model.duration = 10 path = self.model.get_random_path_V2() for step in path: logger.info(step) logger.info("----------------") passed_time = path[-1].next_move.passed_time + path[ -1].next_move.holding_time if set(["failure"]) in [step.ap_set for step in path]: failure_cnt += 1 continue if int(passed_time) < 10: failure = True for step in path: logger.error(step) logger.error("-------------") print "failure_cnt={}".format(failure_cnt) def test_checking(self): # 测试模型检测的成功,从而检测模型解析和SMC算法的正确性 logger.info("checker'result is {}".format(self.checker.run_checker())) def test_regression(self): constants = [("q_trigger", [v for v in range(1, 20, 2)])] self.manager.set_train_constants(*constants) self.manager.train_network() self.manager.set_test_xs([test_x for test_x in product(self.prism_x)]) self.manager.run_test(prism_data_path=get_prism_model_dir() + get_sep() + "Q_TRIGGER_1_20_1.csv")
def get_checker(model, _ltl, duration): return Checker(model, _ltl, duration=duration)
def setUp(self): ModelTestBase.setUp(self) self.duration = 20 self.ltl = "true U<={} result_4".format(self.duration) self.ltl = self._ltl_parser.parse_line(self.ltl) self.checker = Checker(model=self._model, ltl=self.ltl)