experiments.py

from functions import *
from display import *



'''
File to run all experimental setups
'''


def experiment1(X_train, y_train, X_test, y_test, numerical_cols, k_list, filename):

    train_size = len(X_train)
    test_size = len(X_test)

    # train the model and predict y for test data
    y_pred, accuracy = trainXGB(X_train, y_train, X_test, y_test)

    pos_count, neg_count = get_balance(y_pred)

    test_data = prep_X_test(X_test)

    consistencies = []
    for k in k_list:
        consistencies.append(all_definitions(test_data, y_pred, k, numerical_cols, filename))

    return train_size, test_size, accuracy, pos_count, neg_count, consistencies


def experiment2(X_train, y_train, X_test, y_test, numerical_cols, k_list, filename):
    train_size = len(X_train)
    test_size = len(X_test)

    # train the model and predict y for test data
    y_pred, accuracy = trainXGB(X_train, y_train, X_test, y_test)

    test_data = prep_X_test(X_test)

    pos_count, neg_count = get_balance(y_pred)
    min_count = min(pos_count, neg_count)
    test_data, y_pred = cut_dataset(test_data, y_pred, min_count)

    pos_count, neg_count = get_balance(y_pred)

    consistencies = []
    for k in k_list:
        consistencies.append(all_definitions(test_data, y_pred, k, numerical_cols, filename))
    return train_size, test_size, accuracy, pos_count, neg_count, consistencies



def findIF1(id, X_train, y_train, X_test, y_test, numerical_cols, k, sigma):
    # train the model and predict y for test data
    y_pred, accuracy = trainXGB(X_train, y_train, X_test, y_test)

    test_data = prep_X_test(X_test)

    if sigma == 1:
        X_orig, c = sigma1(X_test)
        binned_data, categorical_cols = sigma1(test_data)
    elif sigma == 2:
        X_orig, c = sigma2(X_test, numerical_cols)
        binned_data, categorical_cols = sigma2(test_data, numerical_cols)
    elif sigma == 3:
        X_orig, c = sigma3(X_test, numerical_cols)
        binned_data, categorical_cols = sigma3(test_data, numerical_cols)
    else:
        X_orig, c = sigma4(X_test, numerical_cols)
        binned_data, categorical_cols = sigma4(test_data, numerical_cols)

    example = individual_consistency_score(id, X_orig, binned_data, y_pred, k, categorical_cols)
    save_example(example)


def findIF2(id, X_train, y_train, X_test, y_test, numerical_cols, k, sigma):
    # train the model and predict y for test data
    y_pred, accuracy = trainXGB(X_train, y_train, X_test, y_test)

    pos_count, neg_count = get_balance(y_pred)
    min_count = min(pos_count, neg_count)

    X_orig, y_pred = cut_dataset(X_test, y_pred, min_count)
    test_data = prep_X_test(X_orig)

    if sigma == 1:
        X_orig, c = sigma1(X_orig)
        binned_data, categorical_cols = sigma1(test_data)
    elif sigma == 2:
        X_orig, c = sigma2(X_orig, numerical_cols)
        binned_data, categorical_cols = sigma2(test_data, numerical_cols)
    elif sigma == 3:
        X_orig, c = sigma3(X_orig, numerical_cols)
        binned_data, categorical_cols = sigma3(test_data, numerical_cols)
    else:
        X_orig, c = sigma4(X_orig, numerical_cols)
        binned_data, categorical_cols = sigma4(test_data, numerical_cols)

    example = individual_consistency_score(id, X_orig, binned_data, y_pred, k, categorical_cols)
    save_example(example)

def analyse_results(dataset, k_list):
    data = {}
    k_data = {}
    experiment1 = dataset + "1"
    experiment2 = dataset + "2"

    for k in k_list:
        scores = get_scores_from_file(experiment1, k)
        k_data[str(k)] = Cx_analysis(scores)
        data[experiment1] = k_data

    k_data = {}
    for k in k_list:
        scores = get_scores_from_file(experiment2, k)
        k_data[str(k)] = Cx_analysis(scores)
        data[experiment2] = k_data

    save_analysis(data)


# finds individuals with significant changes in Cx to use as examples
def find_individual_changes(experiment, k):
    scores = get_scores_from_file(experiment, k)
    find_Cx_differences(scores)


def calculate_harmonic_mean(dataset, k_list):
    data = {}
    runs = ["1", "2"]
    for r in runs:
        k_data = []
        experiment = dataset + r
        for k in k_list:
            scores = get_scores_from_file(experiment, k)
            scores = scores.drop('individual id', axis=1)  # Drop unnecessary column

            # Compute the harmonic mean for each column
            harmonic_means = scores.apply(lambda x: harmonic_mean_with_zeros(x))

            # Append the results as a sublist starting with k
            k_data.append([k] + harmonic_means.tolist())

        data[experiment] = k_data

    save_con_results(data, "Tables/harmonic_mean_results.txt")


def calculate_licc_scores(dataset, k_list):
    data = {}
    runs = ["1", "2"]
    for r in runs:
        k_data = []
        experiment = dataset + r
        for k in k_list:
            scores = get_scores_from_file(experiment, k)
            scores = scores.drop('individual id', axis=1)  # Drop unnecessary column

            # Compute the harmonic mean for each column
            licc_scores = scores.apply(lambda x: get_licc_scores_half(x))

            # Append the results as a sublist starting with k
            k_data.append([k] + licc_scores.tolist())

        data[experiment] = k_data

    save_con_results(data, "Tables/licc_score_results.txt")


def create_ic_graph(experiment, k, col1, col2, num_inds_to_show):
    scores = get_scores_from_file(experiment, k)
    filename = experiment + "_" + str(k) + "_ic"
    plot_bar_chart(scores, filename, col1, col2, num_inds_to_show)


def create_sric_graph(experiment, k, col1, col2):
    scores = get_scores_from_file(experiment, k)
    filename = experiment + "_" + str(k) + "_sric"
    # Delta values from 0 to 1 in intervals of 0.2
    delta_values = np.arange(0, 1.1, 0.2)
    # Calculate SRIC scores for each delta
    sric_scores = get_sric_scores(scores, col1, delta_values)
    plot_sric_scores(sric_scores, delta_values, filename)


def create_licc_graph(experiment, k):
    scores = get_scores_from_file(experiment, k)
    filename = experiment + "_" + str(k) + "_licc"
    # Delta values from 0 to 1 in intervals of 0.2
    delta_values = np.arange(0, 1.1, 0.2)
    # Calculate SRIC scores for each delta
    licc_scores = get_licc_scores(scores, delta_values)
    plot_licc_scores(licc_scores, delta_values, filename)


'''
Odinaldo's metrics
'''
def calculate_pcc_scores(dataset, k_list):
    data = {}
    runs = ["1"]
    for r in runs:
        k_data = []
        experiment = dataset + r
        for k in k_list:
            scores = get_scores_from_file(experiment, k)
            scores = scores.drop('individual id', axis=1)  # Drop unnecessary column

            # Compute the harmonic mean for each column
            pcc_scores = scores.apply(lambda x: get_pcc_scores_half(x))

            # Append the results as a sublist starting with k
            k_data.append([k] + pcc_scores.tolist())

        data[experiment] = k_data

    save_con_results(data, "Tables/pcc_score_results.txt")


def calculate_bcc_scores(dataset, k_list):
    data = {}
    runs = ["1"]
    for r in runs:
        k_data = []
        experiment = dataset + r
        for k in k_list:
            scores = get_scores_from_file(experiment, k)
            scores = scores.drop('individual id', axis=1)  # Drop unnecessary column

            # Compute the harmonic mean for each column
            bcc_scores = scores.apply(lambda x: get_bcc_scores_half(x))

            # Append the results as a sublist starting with k
            k_data.append([k] + bcc_scores.tolist())

        data[experiment] = k_data

    save_con_results(data, "Tables/bcc_score_results.txt")


def calculate_bcc_with_penalty_scores(dataset, k_list):
    data = {}
    runs = ["1"]
    for r in runs:
        k_data = []
        experiment = dataset + r
        for k in k_list:
            scores = get_scores_from_file(experiment, k)
            scores = scores.drop('individual id', axis=1)  # Drop unnecessary column

            # Compute the harmonic mean for each column
            bcc_scores = scores.apply(lambda x: get_bcc_penalty_scores_half(x))

            # Append the results as a sublist starting with k
            k_data.append([k] + bcc_scores.tolist())

        data[experiment] = k_data

    save_con_results(data, "Tables/bcc_score_penalty_results.txt")