예제 #1
0
def combine_array(file1, file2):
    f1 = np.array(loadF(file1))
    f2 = np.array(loadF(file2))
    f = np.concatenate((f1, f2), axis=1)
    print(len(f), len(f[0]))
    saveF(f, "400r_CI_result_MMR.pkl")
    return
예제 #2
0
def calculate_variance_h1(f_fname="F_0_1_MMR.pkl"):
    pi_l_list, pi_t_list = dp.get_pil_pit()
    pi_l_list = np.array(pi_l_list).astype(np.float)
    pi_t_list = np.array(pi_t_list).astype(np.float)
    k = len(pi_l_list[0])
    p_list = dp.loadF("h1.pkl")[:-1]
    p_list = np.array(p_list).astype(np.float)
    print("p_list", p_list)
    f0_list, f1_list = dp.loadF(f_fname)
    #print("0,1",f0_list[0],f1_list[0])
    Var_list = []
    for l in range(len(pi_l_list)):
        Var_list.append([])
        for t in range(len(pi_t_list)):
            Var_list[l].append([])
            F = change_f01_to_F(f0_list[l][t], f1_list[l][t])
            for p in range(k):
                var = calculate_variance(pi_l_list[l], pi_t_list[t], p_list[p],
                                         F)
                Var_list[l][t].append(var)
    dp.saveF(Var_list, "var_ltp_h1_" + f_fname[6:-4])
    print("var_list", Var_list)
예제 #3
0
def compare_var(first="var_ltp_h1_optReg", second="var_ltp_h1_MMR"):
    first_var_list = dp.loadF(first)
    second_var_list = dp.loadF(second)
    first_vat_list = np.array(first_var_list)
    second_var_list = np.array(second_var_list)
    L = len(first_var_list)
    T = len(first_var_list[0])
    P = len(first_var_list[0][0])
    total_len = L * T * P
    print(total_len)
    # all 10 p
    rho10 = []
    rho25 = []
    rho50 = []
    rho75 = []
    rho_10 = []
    rho_25 = []
    rho_50 = []
    rho_75 = []
    pos = []
    neg = []
    all_rho = []
    L15_T610_rho = []
    L15_T610_diff = []
    L15_T610_pos = 0
    L610_T15_rho = []
    L610_T15_diff = []
    L610_T15_pos = 0
    L15_T15_rho = []
    L15_T15_diff = []
    L15_T15_pos = 0
    L610_T610_rho = []
    L610_T610_diff = []
    L610_T610_pos = 0
    diag_rho = []
    diag_diff = []
    diag_pos = 0
    for l in range(L):
        for t in range(T):
            for p in range(P):
                rho = calculate_rho(first_var_list[l][t][p],
                                    second_var_list[l][t][p])
                all_rho.append(rho)
                diff = first_var_list[l][t][p] - second_var_list[l][t][p]
                if rho >= 0:
                    pos.append(diff)
                    if rho >= 0.75:
                        rho75.append(diff)
                    if rho >= 0.5:
                        rho50.append(diff)
                    if rho >= 0.25:
                        rho25.append(diff)
                    if rho >= 0.1:
                        rho10.append(diff)
                else:
                    neg.append(diff)
                    if rho <= -0.75:
                        rho_75.append(diff)
                    if rho <= -0.5:
                        rho_50.append(diff)
                    if rho <= -0.25:
                        rho_25.append(diff)
                    if rho <= -0.1:
                        rho_10.append(diff)
                if l < 5:
                    if t < 5:
                        L15_T15_rho.append(rho)
                        L15_T15_diff.append(diff)
                        if rho >= 0:
                            L15_T15_pos += 1
                    else:
                        L15_T610_rho.append(rho)
                        L15_T610_diff.append(diff)
                        if rho >= 0:
                            L15_T610_pos += 1
                else:
                    if t < 5:
                        L610_T15_rho.append(rho)
                        L610_T15_diff.append(diff)
                        if rho >= 0:
                            L610_T15_pos += 1
                    else:
                        L610_T610_rho.append(rho)
                        L610_T610_diff.append(diff)
                        if rho >= 0:
                            L610_T610_pos += 1
                if l == t:
                    diag_rho.append(rho)
                    diag_diff.append(diff)
                    if rho >= 0:
                        diag_pos += 1
    print("10", len(rho10) / total_len, sum(rho10) / len(rho10))
    print("25", len(rho25) / total_len, sum(rho25) / len(rho25))
    print("50", len(rho50) / total_len, sum(rho50) / len(rho50))
    if len(rho75) != 0:
        print("75", len(rho75) / total_len, sum(rho75) / len(rho75))
    print("-10", len(rho_10) / total_len, sum(rho_10) / len(rho_10))
    print("-25", len(rho_25) / total_len, sum(rho_25) / len(rho_25))
    print("-50", len(rho_50) / total_len, sum(rho_50) / len(rho_50))
    print("-75", len(rho_75) / total_len, sum(rho_75) / len(rho_75))
    print("pos",
          len(pos) / total_len, L15_T610_pos / len(L15_T610_rho),
          L610_T15_pos / len(L610_T15_rho), L15_T15_pos / len(L15_T15_rho),
          L610_T610_pos / len(L610_T610_rho), diag_pos / len(diag_rho))
    print("meandiff", (sum(pos) + sum(neg)) / total_len,
          sum(L15_T610_diff) / len(L15_T610_rho),
          sum(L610_T15_diff) / len(L610_T15_rho),
          sum(L15_T15_diff) / len(L15_T15_rho),
          sum(L610_T610_diff) / len(L610_T610_rho),
          sum(diag_diff) / len(diag_rho))
    print("meanrho",
          sum(all_rho) / total_len,
          sum(L15_T610_rho) / len(L15_T610_rho),
          sum(L610_T15_rho) / len(L610_T15_rho),
          sum(L15_T15_rho) / len(L15_T15_rho),
          sum(L610_T610_rho) / len(L610_T610_rho),
          sum(diag_rho) / len(diag_rho))

    # p 1-5
    total_len /= 2
    rho10 = []
    rho25 = []
    rho50 = []
    rho75 = []
    rho_10 = []
    rho_25 = []
    rho_50 = []
    rho_75 = []
    pos = []
    neg = []
    all_rho = []
    L15_T610_rho = []
    L15_T610_diff = []
    L15_T610_pos = 0
    L610_T15_rho = []
    L610_T15_diff = []
    L610_T15_pos = 0
    L15_T15_rho = []
    L15_T15_diff = []
    L15_T15_pos = 0
    L610_T610_rho = []
    L610_T610_diff = []
    L610_T610_pos = 0
    diag_rho = []
    diag_diff = []
    diag_pos = 0
    for l in range(L):
        for t in range(T):
            for p in [0, 1, 2, 3, 4]:
                rho = calculate_rho(first_var_list[l][t][p],
                                    second_var_list[l][t][p])
                all_rho.append(rho)
                diff = first_var_list[l][t][p] - second_var_list[l][t][p]
                if rho >= 0:
                    pos.append(diff)
                    if rho >= 0.75:
                        rho75.append(diff)
                    if rho >= 0.5:
                        rho50.append(diff)
                    if rho >= 0.25:
                        rho25.append(diff)
                    if rho >= 0.1:
                        rho10.append(diff)
                else:
                    neg.append(diff)
                    if rho <= -0.75:
                        rho_75.append(diff)
                    if rho <= -0.5:
                        rho_50.append(diff)
                    if rho <= -0.25:
                        rho_25.append(diff)
                    if rho <= -0.1:
                        rho_10.append(diff)
                if l < 5:
                    if t < 5:
                        L15_T15_rho.append(rho)
                        L15_T15_diff.append(diff)
                        if rho >= 0:
                            L15_T15_pos += 1
                    else:
                        L15_T610_rho.append(rho)
                        L15_T610_diff.append(diff)
                        if rho >= 0:
                            L15_T610_pos += 1
                else:
                    if t < 5:
                        L610_T15_rho.append(rho)
                        L610_T15_diff.append(diff)
                        if rho >= 0:
                            L610_T15_pos += 1
                    else:
                        L610_T610_rho.append(rho)
                        L610_T610_diff.append(diff)
                        if rho >= 0:
                            L610_T610_pos += 1
                if l == t:
                    diag_rho.append(rho)
                    diag_diff.append(diff)
                    if rho >= 0:
                        diag_pos += 1
    print("10", len(rho10) / total_len, sum(rho10) / len(rho10))
    print("25", len(rho25) / total_len, sum(rho25) / len(rho25))
    print("50", len(rho50) / total_len, sum(rho50) / len(rho50))
    if len(rho75) != 0:
        print("75", len(rho75) / total_len, sum(rho75) / len(rho75))
    print("-10", len(rho_10) / total_len, sum(rho_10) / len(rho_10))
    print("-25", len(rho_25) / total_len, sum(rho_25) / len(rho_25))
    print("-50", len(rho_50) / total_len, sum(rho_50) / len(rho_50))
    print("-75", len(rho_75) / total_len, sum(rho_75) / len(rho_75))
    print("pos",
          len(pos) / total_len, L15_T610_pos / len(L15_T610_rho),
          L610_T15_pos / len(L610_T15_rho), L15_T15_pos / len(L15_T15_rho),
          L610_T610_pos / len(L610_T610_rho), diag_pos / len(diag_rho))
    print("meandiff", (sum(pos) + sum(neg)) / total_len,
          sum(L15_T610_diff) / len(L15_T610_rho),
          sum(L610_T15_diff) / len(L610_T15_rho),
          sum(L15_T15_diff) / len(L15_T15_rho),
          sum(L610_T610_diff) / len(L610_T610_rho),
          sum(diag_diff) / len(diag_rho))
    print("meanrho",
          sum(all_rho) / total_len,
          sum(L15_T610_rho) / len(L15_T610_rho),
          sum(L610_T15_rho) / len(L610_T15_rho),
          sum(L15_T15_rho) / len(L15_T15_rho),
          sum(L610_T610_rho) / len(L610_T610_rho),
          sum(diag_rho) / len(diag_rho))

    # p 5-10
    rho10 = []
    rho25 = []
    rho50 = []
    rho75 = []
    rho_10 = []
    rho_25 = []
    rho_50 = []
    rho_75 = []
    pos = []
    neg = []
    all_rho = []
    L15_T610_rho = []
    L15_T610_diff = []
    L15_T610_pos = 0
    L610_T15_rho = []
    L610_T15_diff = []
    L610_T15_pos = 0
    L15_T15_rho = []
    L15_T15_diff = []
    L15_T15_pos = 0
    L610_T610_rho = []
    L610_T610_diff = []
    L610_T610_pos = 0
    diag_rho = []
    diag_diff = []
    diag_pos = 0
    for l in range(L):
        for t in range(T):
            for p in [5, 6, 7, 8, 9]:
                rho = calculate_rho(first_var_list[l][t][p],
                                    second_var_list[l][t][p])
                all_rho.append(rho)
                diff = first_var_list[l][t][p] - second_var_list[l][t][p]
                if rho >= 0:
                    pos.append(diff)
                    if rho >= 0.75:
                        rho75.append(diff)
                    if rho >= 0.5:
                        rho50.append(diff)
                    if rho >= 0.25:
                        rho25.append(diff)
                    if rho >= 0.1:
                        rho10.append(diff)
                else:
                    neg.append(diff)
                    if rho <= -0.75:
                        rho_75.append(diff)
                    if rho <= -0.5:
                        rho_50.append(diff)
                    if rho <= -0.25:
                        rho_25.append(diff)
                    if rho <= -0.1:
                        rho_10.append(diff)
                if l < 5:
                    if t < 5:
                        L15_T15_rho.append(rho)
                        L15_T15_diff.append(diff)
                        if rho >= 0:
                            L15_T15_pos += 1
                    else:
                        L15_T610_rho.append(rho)
                        L15_T610_diff.append(diff)
                        if rho >= 0:
                            L15_T610_pos += 1
                else:
                    if t < 5:
                        L610_T15_rho.append(rho)
                        L610_T15_diff.append(diff)
                        if rho >= 0:
                            L610_T15_pos += 1
                    else:
                        L610_T610_rho.append(rho)
                        L610_T610_diff.append(diff)
                        if rho >= 0:
                            L610_T610_pos += 1
                if l == t:
                    diag_rho.append(rho)
                    diag_diff.append(diff)
                    if rho >= 0:
                        diag_pos += 1
    print("10", len(rho10) / total_len, sum(rho10) / len(rho10))
    print("25", len(rho25) / total_len, sum(rho25) / len(rho25))
    print("50", len(rho50) / total_len, sum(rho50) / len(rho50))
    if len(rho75) != 0:
        print("75", len(rho75) / total_len, sum(rho75) / len(rho75))
    print("-10", len(rho_10) / total_len, sum(rho_10) / len(rho_10))
    print("-25", len(rho_25) / total_len, sum(rho_25) / len(rho_25))
    print("-50", len(rho_50) / total_len, sum(rho_50) / len(rho_50))
    print("-75", len(rho_75) / total_len, sum(rho_75) / len(rho_75))
    print("pos",
          len(pos) / total_len, L15_T610_pos / len(L15_T610_rho),
          L610_T15_pos / len(L610_T15_rho), L15_T15_pos / len(L15_T15_rho),
          L610_T610_pos / len(L610_T610_rho), diag_pos / len(diag_rho))
    print("meandiff", (sum(pos) + sum(neg)) / total_len,
          sum(L15_T610_diff) / len(L15_T610_rho),
          sum(L610_T15_diff) / len(L610_T15_rho),
          sum(L15_T15_diff) / len(L15_T15_rho),
          sum(L610_T610_diff) / len(L610_T610_rho),
          sum(diag_diff) / len(diag_rho))
    print("meanrho",
          sum(all_rho) / total_len,
          sum(L15_T610_rho) / len(L15_T610_rho),
          sum(L610_T15_rho) / len(L610_T15_rho),
          sum(L15_T15_rho) / len(L15_T15_rho),
          sum(L610_T610_rho) / len(L610_T610_rho),
          sum(diag_rho) / len(diag_rho))

    return
예제 #4
0
def percentage_success(filename):
    true_value_list, target_vals_list, clt_inrange, t_inrange, chi_inrange, f_inrange = loadF(
        filename)
    method_list = [clt_inrange, t_inrange, chi_inrange, f_inrange]
    target_data_list = []
    for m in range(len(method_list)):
        analyze_method = method_list[m]
        target_data = []
        opposite_data = []
        for i in range(len(analyze_method)):
            if analyze_method[i] == 1:
                target_data.append(true_value_list[i])
            else:
                opposite_data.append(true_value_list[i])
        ten_value_list = seperate_to_10(target_data)
        opposite_ten_value_list = seperate_to_10(opposite_data)

        target_data_list.append(ten_value_list /
                                (ten_value_list + opposite_ten_value_list))
    plot_hist("Histalgram of percentage success (clt, t, chi, f)",
              len(method_list), target_data_list)
예제 #5
0
def get_variance_info(l, t, p):
    var_list = loadF("process_data\\var_f_optVar" + str(p) + ".pkl")
    return var_list[l][t]
예제 #6
0
def analyze_success(filename):
    true_value_list, target_vals_list, clt_inrange, t_inrange, chi_inrange, f_inrange = loadF(
        filename)
    method_list = [clt_inrange, t_inrange, chi_inrange, f_inrange]
    target_data_list = []
    for m in range(len(method_list)):
        analyze_method = method_list[m]
        target_data = []
        for i in range(len(analyze_method)):
            if analyze_method[i] == 1:
                target_data.append(true_value_list[i])
        ten_value_list = seperate_to_10(target_data)
        ten_value_list /= len(target_data)
        target_data_list.append(ten_value_list)
    plot_hist("Histalgram of true value in CI (clt, t, chi, f)",
              len(method_list), target_data_list, 0, 10, 0, 0.25)
예제 #7
0
def analyze_value(filename, index=0):
    true_value_list, target_vals_list, clt_inrange, t_inrange, chi_inrange, f_inrange = loadF(
        filename)
    if index == 0:
        ten_value_list = seperate_to_10(true_value_list)
    ten_value_list /= len(true_value_list)
    plot_hist("Histalgram of true value", 1, [ten_value_list])
    return
예제 #8
0
def scatter_plot(coverage_file, seperate_variance=False, variance_file=None):
    coverage = loadF(coverage_file)
    fig = plt.figure()
    if seperate_variance == False:
        # get x and y
        x = []
        y = coverage
        for l in range(11):
            for p in range(10):
                for t in range(11):
                    variance = get_variance_info(l, t, p)
                    x.append(variance)

        # calculate covariance
        covariance = stats.pearsonr(x, y)
        print(covariance)

        # plot
        plt.scatter(x, y, s=0.6, color='blue')
        plt.xlabel('variance by formula')
        plt.ylabel('coverage')
        plt.show()
        fig.savefig('1' + '.pdf', bbox_inches='tight')
    elif seperate_variance == "mean":
        variance = loadF(variance_file)
        # calculate covariance
        covariance = stats.pearsonr(variance, coverage)
        print(covariance)
        plt.scatter(variance, coverage, s=0.6, color='blue')
        plt.xlabel('variance by 400 instance')
        plt.ylabel('coverage')
        plt.show()
        fig.savefig('2' + '.pdf', bbox_inches='tight')
    elif seperate_variance == "VvsV":
        variance_ins = loadF(variance_file)
        x = []
        for l in range(11):
            for p in range(10):
                for t in range(11):
                    variance = get_variance_info(l, t, p)
                    x.append(variance)
        variance_formula = x
        # calculate covariance
        covariance = stats.pearsonr(variance_ins, variance_formula)
        print(covariance)
        plt.scatter(variance_ins, variance_formula, s=0.6, color='blue')
        plt.xlabel('variance by 400 instance')
        plt.ylabel('variance by formula')
        plt.show()
        fig.savefig('3' + '.pdf', bbox_inches='tight')
    else:
        x1 = []
        x2 = []
        y1 = []
        y2 = []
        i = 0
        for l in range(11):
            for p in range(10):
                for t in range(11):
                    variance = get_variance_info(l, t, p)
                    if variance <= seperate_variance:
                        x1.append(variance)
                        y1.append(coverage[i])
                    else:
                        x2.append(variance)
                        y2.append(coverage[i])
                    i += 1
        print("len for <= " + str(seperate_variance) + ": " + str(len(x1)))
        print("len for >  " + str(seperate_variance) + ": " + str(len(x2)))
        # calculate covariance
        covariance1 = stats.pearsonr(x1, y1)
        covariance2 = stats.pearsonr(x2, y2)
        print("covarance <= " + str(seperate_variance), covariance1)
        print("covarance >  " + str(seperate_variance), covariance2)
        # plot
        plt.scatter(x1, y1, s=0.7, color='blue')
        plt.xlabel('variance by formula <= ' + str(seperate_variance))
        plt.ylabel('coverage')
        plt.show()
        fig.savefig('4' + '.pdf', bbox_inches='tight')
        plt.scatter(x2, y2, s=0.7, color='blue')
        plt.xlabel('variance by formula > ' + str(seperate_variance))
        plt.ylabel('coverage')
        plt.show()
        fig.savefig('5' + '.pdf', bbox_inches='tight')
예제 #9
0
def analyze_mean(mean_file, ind_file, ind=None):
    mean_list = loadF(mean_file)
    ind_list_clt, ind_list_t, ind_list_chi, ind_list_f = loadF(ind_file)
    total_list = ind_list_clt + ind_list_t + ind_list_chi + ind_list_f
    total_list = list(dict.fromkeys(total_list))
    mean_list = np.array(mean_list).astype(np.float)
    if ind != None:
        if ind == "inf":
            for i in total_list:
                print("=====================================================")
                target_mean_list = mean_list[i]
                # normality
                print(stats.normaltest(target_mean_list))
                min_x = min(target_mean_list)
                max_x = max(target_mean_list)
                print("min and max:", min_x, max_x)
                target_mean_list -= min_x
                target_mean_list /= max_x - min_x
                [ind_name], l, t, p = get_name_from_index([i])
                print(ind_name)
                # get variance
                variance = get_variance_info(l, t, p)
                print("variance:", variance)
                ten_val_list = seperate_to_10(target_mean_list) / len(
                    target_mean_list)
                plot_hist(
                    str(len(mean_list[0])) +
                    "r Histalgram of mean value with small coverage (" +
                    ind_name[:3] + ")", 1, [ten_val_list], min_x, max_x, 0, 1,
                    "Estimates")
        else:
            target_mean_list = mean_list[ind]
            print(stats.normaltest(target_mean_list))
            min_x = min(target_mean_list)
            max_x = max(target_mean_list)
            print("min and max:", min_x, max_x)
            target_mean_list -= min_x
            target_mean_list /= max_x - min_x
            [ind_name], l, t, p = get_name_from_index([ind])
            print(ind_name)
            # get variance
            variance = get_variance_info(l, t, p)
            print("variance:", variance)
            ten_val_list = seperate_to_10(target_mean_list) / len(
                target_mean_list)
            plot_hist(
                str(len(mean_list[0])) +
                "r Histalgram of mean value with small coverage (" +
                ind_name[:3] + ")", 1, [ten_val_list], min_x, max_x, 0, 1,
                "Estimates")

    else:
        target_mean_list = np.concatenate(mean_list[total_list])
        print(get_name_from_index(total_list))
        ten_val_list = seperate_to_10(target_mean_list) / len(target_mean_list)
        plot_hist(
            str(len(mean_list[0])) +
            "r Histalgram of mean value with small coverage", 1,
            [ten_val_list])

    return
예제 #10
0
def get_info_coverage(filename, info_type, estimator="MMR"):
    true_value_list, target_vals_list, clt_inrange, t_inrange, chi_inrange, f_inrange = loadF(
        filename)
    coverage_list_clt = np.zeros(1210)
    coverage_list_t = np.zeros(1210)
    coverage_list_chi = np.zeros(1210)
    coverage_list_f = np.zeros(1210)
    case_target_val = [[] for _ in range(1210)]

    for i in range(len(target_vals_list)):
        coverage_list_clt[i % 1210] += clt_inrange[i]
        coverage_list_t[i % 1210] += t_inrange[i]
        coverage_list_chi[i % 1210] += chi_inrange[i]
        coverage_list_f[i % 1210] += f_inrange[i]
        case_target_val[i % 1210].append(target_vals_list[i])

    saveF(
        case_target_val, "mean_" + str(int(len(target_vals_list) / 1210)) +
        "r_" + estimator + ".pkl")

    # save variance
    var_mean_list = []
    for i in range(len(case_target_val)):
        var_mean_list.append(np.var(case_target_val[i]))
    saveF(
        var_mean_list, "var_mean_" + str(int(len(target_vals_list) / 1210)) +
        "r_" + estimator + ".pkl")

    coverage_list_clt /= (len(clt_inrange) / 1210)
    coverage_list_t /= (len(clt_inrange) / 1210)
    coverage_list_chi /= (len(clt_inrange) / 1210)
    coverage_list_f /= (len(clt_inrange) / 1210)

    saveF(coverage_list_clt, "coverage_clt_" + estimator + ".pkl")
    saveF(coverage_list_t, "coverage_t_" + estimator + ".pkl")
    saveF(coverage_list_chi, "coverage_chi_" + estimator + ".pkl")
    saveF(coverage_list_f, "coverage_f_" + estimator + ".pkl")

    overall_cov_clt = np.mean(coverage_list_clt)
    overall_cov_t = np.mean(coverage_list_t)
    overall_cov_chi = np.mean(coverage_list_chi)
    overall_cov_f = np.mean(coverage_list_f)
    print("overall coverage (clt,t,chi,f):", overall_cov_clt, overall_cov_t,
          overall_cov_chi, overall_cov_f)

    if info_type == "min":
        cut_point_clt = np.percentile(coverage_list_clt, 0.49)
        cut_point_t = np.percentile(coverage_list_t, 0.49)
        cut_point_chi = np.percentile(coverage_list_chi, 0.49)
        cut_point_f = np.percentile(coverage_list_f, 0.49)

        print("min of clt,t,chi,f ; 0.5 percentile:")
        print(min(coverage_list_clt), cut_point_clt)
        print(min(coverage_list_t), cut_point_t)
        print(min(coverage_list_chi), cut_point_chi)
        print(min(coverage_list_f), cut_point_f)

        ind_list_clt = []
        ind_list_t = []
        ind_list_chi = []
        ind_list_f = []

        for i in range(1210):
            if coverage_list_clt[i] <= cut_point_clt:
                ind_list_clt.append(i)
            if coverage_list_t[i] <= cut_point_t:
                ind_list_t.append(i)
            if coverage_list_chi[i] <= cut_point_chi:
                ind_list_chi.append(i)
            if coverage_list_f[i] <= cut_point_f:
                ind_list_f.append(i)

        print("indlist:", ind_list_clt, ind_list_t, ind_list_chi, ind_list_f)
        saveF([ind_list_clt, ind_list_t, ind_list_chi, ind_list_f],
              "ind_" + str(int(len(target_vals_list) / 1210)) + "r_" +
              estimator + ".pkl")
        print("ind_" + str(int(len(target_vals_list) / 1210)) + "r_" +
              estimator + ".pkl")

    else:
        cut_point_clt = np.percentile(coverage_list_clt, 99.5)
        cut_point_t = np.percentile(coverage_list_t, 99.5)
        cut_point_chi = np.percentile(coverage_list_chi, 99.5)
        cut_point_f = np.percentile(coverage_list_f, 99.5)

        print("max of clt,t,chi,f ; 99.5 percentile:")
        print(max(coverage_list_clt), cut_point_clt)
        print(max(coverage_list_t), cut_point_t)
        print(max(coverage_list_chi), cut_point_chi)
        print(max(coverage_list_f), cut_point_f)

        ind_list_clt = []
        ind_list_t = []
        ind_list_chi = []
        ind_list_f = []

        for i in range(1210):
            if coverage_list_clt[i] >= cut_point_clt:
                ind_list_clt.append(i)
            if coverage_list_t[i] >= cut_point_t:
                ind_list_t.append(i)
            if coverage_list_chi[i] >= cut_point_chi:
                ind_list_chi.append(i)
            if coverage_list_f[i] >= cut_point_f:
                ind_list_f.append(i)

        print("indlist:", ind_list_clt, ind_list_t, ind_list_chi, ind_list_f)
        saveF([ind_list_clt, ind_list_t, ind_list_chi, ind_list_f],
              "ind_" + str(int(len(target_vals_list) / 1210)) + "r_max_" +
              estimator + ".pkl")
        print("ind_" + str(int(len(target_vals_list) / 1210)) + "r_max_" +
              estimator + ".pkl")

    return
예제 #11
0
def check_data(filename):
    true_value_list, target_vals_list, clt_inrange, t_inrange, chi_inrange, f_inrange = loadF(
        filename)
    print(np.mean(target_vals_list), len(target_vals_list))
예제 #12
0
def get_data(filename, index):
    # if the data is [data1, data2] and index is 0, we will only get data1
    data = dp.loadF(filename)
    if index != None:
        data = data[index]
    return data
예제 #13
0
def off_policy_target_value(a, delta, pi_l, pi_t, p_astar):
    data = dp.loadF("process_data\F_0_1_optVar" + str(p_astar) + ".pkl")
    data = data[delta][pi_l][pi_t][a]
    return data