Exemple #1
0
def learnOTA_normal(system, actions, upper_guard, epsilon, delta, state_num,
                    debug_flag):
    need_to_explore = queue.PriorityQueue()

    # init table
    for table in init_table_normal(actions, system):
        # table.show()
        need_to_explore.put((table.table_id, table))  # 优先级为表格的有效长度

    # List of existing counterexamples
    prev_ctx = []

    # Current number of tables
    t_number = 0
    target = None

    while True:
        if need_to_explore.qsize() == 0:
            break
        depth, current_table = need_to_explore.get()
        t_number = t_number + 1

        print("Table %s: current %s has parent-%s by %s" %
              (t_number, current_table.table_id, current_table.parent,
               current_table.reason))
        if debug_flag:
            current_table.show()
            print("--------------------------------------------------")

        # First check if the table is closed
        flag_closed, closed_move = current_table.is_closed()
        if not flag_closed:
            if debug_flag:
                print(
                    "------------------make closed--------------------------")
            temp_tables = make_closed(closed_move, actions, current_table,
                                      system)
            if len(temp_tables) > 0:
                for table in temp_tables:
                    # table.show()
                    need_to_explore.put((table.table_id, table))
            continue

        # If is closed, check if the table is consistent
        flag_consistent, prefix_LTWs, e_index, reset_i, reset_j, index_i, index_j = current_table.is_consistent(
        )
        if not flag_consistent:
            if debug_flag:
                print(
                    "------------------make consistent--------------------------"
                )
            temp_tables = make_consistent(prefix_LTWs, e_index, reset_i,
                                          reset_j, index_i, index_j,
                                          current_table, system)
            if len(temp_tables) > 0:
                for table in temp_tables:
                    # table.show()
                    need_to_explore.put((table.table_id, table))
            continue

        # If prepared, check conversion to FA
        discreteOTA = struct_discreteOTA(current_table, actions)
        if discreteOTA is None:
            continue
        if debug_flag:
            print("***************** discreteOTA_" + str(system.eq_num + 1) +
                  " is as follow. *******************")
            discreteOTA.show_discreteOTA()

        # Convert FA to OTA
        hypothesisOTA = struct_hypothesisOTA(discreteOTA)
        if debug_flag:
            print("***************** Hypothesis_" + str(system.eq_num + 1) +
                  " is as follow. *******************")
            hypothesisOTA.show_OTA()

        equivalent, ctx = True, None
        if prev_ctx is not None:
            for ctx in prev_ctx:
                real_outputs = system.test_DTWs_normal(ctx)
                outputs = hypothesisOTA.test_DTWs_normal(ctx)
                if real_outputs != outputs:
                    equivalent = False
                    ctx = minimize_counterexample_normal(
                        hypothesisOTA, system, ctx)
                    break

        if equivalent:
            system.eq_num += 1
            equivalent, ctx = EQs(hypothesisOTA, upper_guard, epsilon, delta,
                                  system.eq_num, state_num, system)

        if not equivalent:
            # show ctx
            if debug_flag:
                print(
                    "***************** counterexample is as follow. *******************"
                )
                print([dtw.show() for dtw in ctx])
            # deal with ctx
            if ctx not in prev_ctx:
                prev_ctx.append(ctx)
            temp_tables = deal_ctx(current_table, ctx, system)
            if len(temp_tables) > 0:
                for table in temp_tables:
                    # table.show()
                    need_to_explore.put((table.table_id, table))
        else:
            target = copy.deepcopy(hypothesisOTA)
            break
    if target is not None:
        target = target.build_simple_hypothesis()

    return target, system.mq_num, system.eq_num, system.test_num, system.test_num_cache, system.action_num, t_number
def learnOTA_normal_level(system, actions, upper_guard, epsilon, delta,
                          state_num, debug_flag):
    level = 0
    cur_level_neel_to_explore = queue.PriorityQueue()
    next_level_need_to_explore = queue.PriorityQueue()
    cur_level_hypothesis = queue.PriorityQueue()

    # init table
    for table in init_table_normal(actions, system):
        cur_level_neel_to_explore.put((table.table_id, table))

    prev_ctx = []  # List of existing counterexamples
    t_number = 0  # Current number of tables
    target = None
    learn_flag = False
    m_i = 0

    while not learn_flag:
        if cur_level_neel_to_explore.qsize() == 0:
            break

        while cur_level_neel_to_explore.qsize() > 0:
            flag = False
            depth, current_table = cur_level_neel_to_explore.get()
            t_number = t_number + 1

            if check_guess_table_correct(current_table, system):
                flag = True
                print('***************** Now is Correct *****************')

            print("Table %s: %s has parent-%s by %s" %
                  (t_number, current_table.table_id, current_table.parent,
                   current_table.reason))
            if debug_flag:
                current_table.show()
                print("--------------------------------------------------")

            # First check if the table is closed
            flag_closed, closed_move = current_table.is_closed()
            if not flag_closed:
                if debug_flag:
                    print(
                        "------------------make closed--------------------------"
                    )
                temp_tables = make_closed(closed_move, actions, current_table,
                                          system)
                temp_flag = False
                count = []
                if flag and len(temp_tables) == 0:
                    raise Exception('Attention-1.1!!!')
                if len(temp_tables) > 0:
                    for table in temp_tables:
                        if flag and check_guess_table_correct(table, system):
                            count.append(table)
                            temp_flag = True
                        cur_level_neel_to_explore.put((table.table_id, table))
                if len(count) > 1:
                    raise Exception('Attention-1.2!!!')
                if flag and not temp_flag:
                    raise Exception('Attention-1.3!!!')
                continue

            # If is closed, check if the table is consistent
            flag_consistent, prefix_LTWs, e_index, reset_i, reset_j, index_i, index_j = current_table.is_consistent(
            )
            if not flag_consistent:
                if debug_flag:
                    print(
                        "------------------make consistent--------------------------"
                    )
                temp_tables = make_consistent(prefix_LTWs, e_index, reset_i,
                                              reset_j, index_i, index_j,
                                              current_table, system)
                temp_flag = False
                count = []
                if flag and len(temp_tables) == 0:
                    raise Exception('Attention-2.1!!!')
                if len(temp_tables) > 0:
                    for table in temp_tables:
                        if flag and check_guess_table_correct(table, system):
                            count.append(table)
                            temp_flag = True
                        cur_level_neel_to_explore.put((table.table_id, table))
                if len(count) > 1:
                    raise Exception('Attention-2.2!!!')
                if flag and not temp_flag:
                    raise Exception('Attention-2.3!!!')
                continue

            # If prepared, check conversion to FA
            discreteOTA = struct_discreteOTA(current_table, actions)
            if discreteOTA is None:
                continue
            if debug_flag:
                print("***************** discreteOTA_" +
                      str(system.eq_num + 1) +
                      " is as follow. *******************")
                discreteOTA.show_discreteOTA()

            # Convert FA to OTA
            hypothesisOTA = struct_hypothesisOTA(discreteOTA)
            if debug_flag:
                print("***************** Hypothesis_" +
                      str(system.eq_num + 1) +
                      " is as follow. *******************")
                hypothesisOTA.show_OTA()

            cur_level_hypothesis.put(
                (len(hypothesisOTA.states), hypothesisOTA, current_table))

        if cur_level_hypothesis.qsize() == 0:
            break

        print('———————————————— 当前level完成 ————————————————')

        m_i = cur_level_hypothesis.qsize()
        while cur_level_hypothesis.qsize() > 0:
            flag = False
            hyp_state_num, cur_hypothesis, current_table = cur_level_hypothesis.get(
            )

            if check_guess_table_correct(current_table, system):
                flag = True
                print(
                    '***************** Now hypothesis is Correct *****************'
                )
                print("%s has parent-%s by %s" %
                      (current_table.table_id, current_table.parent,
                       current_table.reason))

            equivalent, ctx = True, None
            if prev_ctx is not None:
                for ctx in prev_ctx:
                    real_outputs = system.test_DTWs_normal(ctx, True)
                    outputs = cur_hypothesis.test_DTWs_normal(ctx)
                    if real_outputs != outputs:
                        equivalent = False
                        ctx = minimize_counterexample_normal(
                            cur_hypothesis, system, ctx)
                        break

            if equivalent:
                system.eq_num += 1
                equivalent, ctx = EQs_level(cur_hypothesis, upper_guard,
                                            epsilon, delta, level, m_i,
                                            state_num, system)

            if not equivalent:
                # show ctx
                if debug_flag:
                    print(
                        "***************** counterexample is as follow. *******************"
                    )
                    print([dtw.show() for dtw in ctx])
                # deal with ctx
                if ctx not in prev_ctx:
                    prev_ctx.append(ctx)
                temp_tables = deal_ctx(current_table, ctx, system)
                temp_flag = False
                count = []
                if flag and len(temp_tables) == 0:
                    raise Exception('Attention-3.1!!!')
                if len(temp_tables) > 0:
                    for table in temp_tables:
                        if flag and check_guess_table_correct(table, system):
                            count.append(table)
                            temp_flag = True
                        next_level_need_to_explore.put((table.table_id, table))
                if len(count) > 1:
                    raise Exception('Attention-3.2!!!')
                if flag and not temp_flag:
                    raise Exception('Attention-3.3!!!')
            else:
                learn_flag = True
                target = copy.deepcopy(cur_hypothesis)
                break
        level += 1
        cur_level_neel_to_explore = next_level_need_to_explore
        next_level_need_to_explore = queue.PriorityQueue()
    if target is not None:
        target = target.build_simple_hypothesis()
    return target, system.mq_num, system.eq_num, system.test_num, system.test_num_cache, system.action_num, t_number, level, m_i
Exemple #3
0
def random_steps(current_table, actions, prev_ctx, system, debug_flag):
    while True:
        # First check if the table is closed
        flag_closed, closed_move = current_table.is_closed()
        if not flag_closed:
            if debug_flag:
                print(
                    "------------------make closed--------------------------")
            temp_tables = make_closed(closed_move, actions, current_table,
                                      system)
            if len(temp_tables) > 0:
                current_table = random.sample(temp_tables, 1)[0]
                continue
            else:
                return False, None

        # If is closed, check if the table is consistent
        flag_consistent, prefix_LTWs, e_index, reset_i, reset_j, index_i, index_j = current_table.is_consistent(
        )
        if not flag_consistent:
            if debug_flag:
                print(
                    "------------------make consistent--------------------------"
                )
            temp_tables = make_consistent(prefix_LTWs, e_index, reset_i,
                                          reset_j, index_i, index_j,
                                          current_table, system)
            if len(temp_tables) > 0:
                current_table = random.sample(temp_tables, 1)[0]
                continue
            else:
                return False, None

        # If prepared, check conversion to FA
        discreteOTA = struct_discreteOTA(current_table, actions)
        if discreteOTA is None:
            return False, None
        if debug_flag:
            print("***************** discreteOTA_" + str(system.eq_num + 1) +
                  " is as follow. *******************")
            discreteOTA.show_discreteOTA()

        # Convert FA to OTA
        hypothesisOTA = struct_hypothesisOTA(discreteOTA)
        if debug_flag:
            print("***************** Hypothesis_" + str(system.eq_num + 1) +
                  " is as follow. *******************")
            hypothesisOTA.show_OTA()

        equivalent, ctx = True, None
        if prev_ctx is not None:
            for ctx in prev_ctx:
                real_outputs = system.test_DTWs_normal(ctx)
                outputs = hypothesisOTA.test_DTWs_normal(ctx)
                if real_outputs != outputs:
                    equivalent = False
                    ctx = minimize_counterexample_normal(
                        hypothesisOTA, system, ctx)
                    break

        if not equivalent:
            if debug_flag:
                print(
                    "***************** counterexample is as follow. *******************"
                )
                print([dtw.show() for dtw in ctx])
            temp_tables = deal_ctx(current_table, ctx, system)
            if len(temp_tables) > 0:
                current_table = random.sample(temp_tables, 1)[0]
                continue
            else:
                return False, None
        else:
            return True, current_table