evaluation_code/dp_bench_evaluations.py

from os import sched_get_priority_max

from tqdm import tqdm
import numpy as np
from prompting_utils import *
from utils import *
from sql_comparison import *
import pickle

def add_fk_tabcols(tables, schema_pk_fk):
    to_add = defaultdict(lambda: set())
    for tab in tables:
        if tab in schema_pk_fk:
            tab_to_tab = schema_pk_fk[tab]
            for ftab in tables:
                if ftab in tab_to_tab:
                    for pkfk in tab_to_tab[ftab]:
                        # print(pkfk)
                        to_add[pkfk[0][0]].add(pkfk[0][1])
                        to_add[pkfk[1][0]].add(pkfk[1][1])
    return {k:v for k,v in to_add.items()}

def score_prediction(gt: DataBase, pred: DataBase, all_relevant:bool=False, beta:float=1):
    pred_total = pred.get_column_count(include_derived_columns=all_relevant)
    if pred_total == 0:
        return 0,0,0
    correct_count = gt.compare_column_overlap(other_db=pred, include_derived_columns=all_relevant)
    gt_total = gt.get_column_count(include_derived_columns=all_relevant)

    precision = correct_count / pred_total
    recall = correct_count / gt_total
    if precision+recall == 0:
        f1 = 0
    else:
        if beta == 1:
            f1 = 2 * (precision * recall) / (precision + recall)
        else:
            f1 = (1+beta**2)*(precision*recall)/(((beta**2)*precision)+recall)

    return precision, recall, f1

def micro_counts(gt: DataBase, pred: DataBase, all_relevant:bool=False):
    pred_total = pred.get_column_count(include_derived_columns=all_relevant)
    if pred_total == 0:
        return 0,0,0
    correct_count = gt.compare_column_overlap(other_db=pred, include_derived_columns=all_relevant)
    gt_total = gt.get_column_count(include_derived_columns=all_relevant)

    truepos = correct_count
    falsepos = pred_total - correct_count
    falseneg = gt_total - correct_count
    return truepos, falsepos, falseneg

def get_executable_SQL_list(question_SQLs, gt_db: DataBase, pred_db: DataBase, base_schema: DataBase):
    schema_dict = base_schema.get_schema_for_sqlglot()
    all_real_cols = set()
    for t,table in base_schema.tables.items():
        all_real_cols |= table.columns

    good = 0
    total = 0
    bad_content = []
    req_tabcols = defaultdict(lambda: set())
    executable_q_gt = []
    for question, sql in question_SQLs.items():
        clean_q1 = cleanup_query(sql, schema_dict)
        tab_cols = []
        for column_expression in clean_q1.find_all(exp.Column):

            if str(column_expression.this).replace('"', '') not in all_real_cols:
                # print(column_expression, column_expression.name, type(column_expression))
                continue
            try:
                if str(column_expression.args['table'].this).replace('"', '').startswith("_"):
                    continue
                # a common pattern where sqlglot seems to fail to fully parse out some table aliases
                elif str(column_expression.args['table'].this).replace('"', '') in {"t", "t1"}:
                    continue
                tab_cols.append((str(column_expression.args['table'].this).replace('"', ''),
                             str(column_expression.this).replace('"', '')))
            except KeyError:
                pass
            except AttributeError:
                pass

        tab_cols = set(tab_cols)
        pred_can_execute = True
        for (tab,col) in tab_cols:
            if not (tab in pred_db.tables and col in pred_db.tables[tab].columns):
                pred_can_execute = False
            req_tabcols[tab].add(col)
            if not (tab in gt_db.tables and col in gt_db.tables[tab].columns):
                bad_content.append((sql, (tab, col)))
            req_tabcols[tab].add(col)
        if pred_can_execute:
            executable_q_gt.append((question, sql))


    return executable_q_gt

def compare_derived_col_sims(gt_db: DataBase, pred_db: DataBase, base_schema: DataBase, cutoff_threshold: float = 0.0):
    sims = []
    diffcounts = []
    schema = base_schema.get_schema_for_sqlglot()
    sim_score_matrix = []
    diff_score_matrix = []
    gt_order_dict = {}
    pred_order_dict = {}
    for gt_ind, gt_derived in enumerate(gt_db.derived_columns):
        gt_sql = gt_derived.provenance_sql
        gt_order_dict[gt_ind] = gt_sql
        this_sims = []
        this_diffs = []
        for pred_ind, pred_derived in enumerate(pred_db.derived_columns):
            pred_sql = pred_derived.provenance_sql
            pred_order_dict[pred_ind] = pred_sql
            sim = sql_diff_sim(gt_sql, pred_sql, schema=schema)
            diff_count, total_count = get_nonalias_diff(gt_sql, pred_sql, schema=schema)
            if sim is None:
                this_sims.append(-1)
                this_diffs.append(999)
            else:
                this_diffs.append(diff_count)
                this_sims.append(sim)
        sim_score_matrix.append(this_sims)
        diff_score_matrix.append(this_diffs)
    gt_sim_maps = solve_optimal_mapping(sim_score_matrix)

    for from_ind, to_ind in gt_sim_maps.items():
        sims.append(sim_score_matrix[from_ind][to_ind])
        diffcounts.append(diff_score_matrix[from_ind][to_ind])
    for gt_ind in gt_order_dict.keys():
        if gt_ind not in gt_sim_maps:
            sims.append(0)
            diffcounts.append(999)
    return sims, diffcounts

def calc_results(all_predictions, gt_data, schema_data,
                 evaluate_derived_columns_soft_match:bool=False):
    schema_table_pk_fk = {}
    for db, tabcols in raw_schema_data.items():
        schema_table_pk_fk[db] = defaultdict(lambda: defaultdict(lambda: list()))
        tables = []
        for tab, cd in tabcols['tables'].items():
            tables.append(Table(name=tab.lower(), columns=set(col['name'] for col in cd['columns']),
                                column_types={col['name']: col['type'].upper() for col in cd['columns']}))
            for col in cd['columns']:
                if col['foreign_key']:
                    assert len(col['foreign_key']) == 2
                    schema_table_pk_fk[db][tab.lower()][col['foreign_key'][0]].append(
                        ((tab.lower(), col['name']),
                         (col['foreign_key'][0], col['foreign_key'][1])))
        schema_data[db] = DataBase(name=db, tables={t.name: t for t in tables})
        assert not any("." in c for c in {col['name']: col['type'].upper() for col in cd['columns']})
        assert not any("__" in c for c in {col['name']: col['type'].upper() for col in cd['columns']})

    sizes = []
    gt_sizes = []
    precisions = []
    recalls = []
    f1s = []
    micro_tp = 0
    micro_fp = 0
    micro_fn = 0
    all_relevant_sizes = []
    gt_all_relevant_sizes = []
    all_relevant_precisions = []
    all_relevant_recalls = []
    all_relevant_f1s = []

    macro_derived_sims = []
    micro_derived_sims = []
    macro_derived_diffs = []
    micro_derived_diffs = []

    derived_soft_prec = []
    derived_soft_rec = []
    derived_soft_f1 = []

    is_hard = []
    print("starting eval...")
    with open((BENCH_DIR / "v7_hard_dp_bench_with_topics.json").resolve(), 'r') as f:
        hard_subset = json.load(f)
    hard_subset = set(hard_subset.keys())
    for database, pred_list in tqdm(all_predictions.items()):
        if not pred_list:
            continue
        base_schema = schema_data[database]
        for dpr_pred in pred_list:

            if database in hard_subset:
                is_hard.append(1)
            else:
                is_hard.append(0)

            gt_db = gt_to_db(dbname=database, raw_gt_data_product=gt_data[database])
            gt_db = filter_real_table_columns(real_db=base_schema, filter_db=gt_db, debug=True)
            pred_tabcols = dpr_pred['PREDICTION']

            if pred_tabcols is not None:
                for tab,cols in add_fk_tabcols(list(pred_tabcols.keys()), schema_table_pk_fk[database]).items():
                    pred_tabcols[tab] += list(cols)
                    pred_tabcols[tab] = list(set(pred_tabcols[tab]))
            pred_db = viewgen_pred_to_db(pred_content=dpr_pred['PREDICTION'], dbname=database)
            pred_db = filter_real_table_columns(real_db=base_schema, filter_db=pred_db)

            all_relevant_result = score_prediction(gt=gt_db, pred=pred_db, all_relevant=True)
            non_derivation_result = score_prediction(gt=gt_db, pred=pred_db, all_relevant=False)

            micro_tpt, micro_fpt, micro_fnt = micro_counts(gt_db, pred_db, all_relevant=True)
            micro_tp += micro_tpt
            micro_fp += micro_fpt
            micro_fn += micro_fnt

            dpr_pred['all_relevant_res'] = all_relevant_result
            dpr_pred['nonderived_res'] = non_derivation_result

            precisions.append(non_derivation_result[0])
            recalls.append(non_derivation_result[1])
            f1s.append(non_derivation_result[2])

            all_relevant_precisions.append(all_relevant_result[0])
            all_relevant_recalls.append(all_relevant_result[1])
            all_relevant_f1s.append(all_relevant_result[2])
            sizes.append(pred_db.get_column_count(include_derived_columns=False) / base_schema.get_column_count(
                include_derived_columns=False))
            gt_sizes.append(gt_db.get_column_count(include_derived_columns=False) / base_schema.get_column_count(
                include_derived_columns=False))

            all_relevant_sizes.append(
                pred_db.get_column_count(include_derived_columns=True) / base_schema.get_column_count(
                    include_derived_columns=True))
            gt_all_relevant_sizes.append(
                gt_db.get_column_count(include_derived_columns=True) / base_schema.get_column_count(
                    include_derived_columns=True))

            if evaluate_derived_columns_soft_match:
                if len(gt_db.derived_columns) == 0:
                    continue
                sim, diff = compare_derived_col_sims(gt_db, pred_db, base_schema)
                micro_derived_sims += sim
                micro_derived_diffs += diff
                macro_derived_sims.append(np.mean(sim))
                macro_derived_diffs.append(np.mean(diff))
                if len(pred_db.derived_columns) == 0:
                    derived_soft_prec.append(0)
                    derived_soft_rec.append(0)
                    derived_soft_f1.append(0)
                else:
                    derived_soft_prec.append(sprec:=(sum(sim) / len(pred_db.derived_columns)))
                    derived_soft_rec.append(srec:=(sum(sim) / len(gt_db.derived_columns)))
                    if sprec == 0 or srec == 0:
                        derived_soft_f1.append(0)
                    else:
                        derived_soft_f1.append(2*(sprec*srec)/(sprec+srec))

    print("XXXXXXXX")
    print("XXXXXXXX")
    print("Results")
    print("Non-derived columns only:")
    print(f"GT DP size: avg: {np.mean(gt_sizes):.3f}")
    print(f"Predicted DP size avg: {np.mean(sizes):.3f}")
    print("- P/R/F1-")
    print(f"Precision: {np.mean(precisions):.3f}")
    print(f"Recall: {np.mean(recalls):.3f}")
    print(f"F1: {np.mean(f1s):.3f}")
    print("-")
    print("Including derived columnss:")
    print(f"GT DP size: avg: {np.mean(gt_all_relevant_sizes):.3f}")
    print(f"Predicted DP size avg: {np.mean(all_relevant_sizes):.3f}")
    print("- P/R/F1-")
    print(f"Precision: {np.mean(all_relevant_precisions):.3f}")
    print(f"Recall: {np.mean(all_relevant_recalls):.3f}")
    print(f"F1: {np.mean(all_relevant_f1s):.3f}")
    print("-")

    # print(f"{np.mean(precisions):.3f} & {np.mean(recalls):.3f} & {np.mean(f1s):.3f} & {np.mean(all_relevant_precisions):.3f} & {np.mean(all_relevant_recalls):.3f} & {np.mean(all_relevant_f1s):.3f}")
    if evaluate_derived_columns_soft_match:
        print(f"Derived column stats")
        print(f"Average similarity: {np.mean(macro_derived_sims):.3f}, Median diff count between ASTs: {np.median(macro_derived_diffs):.3f}")
        print(f"Soft Precision: {np.mean(derived_soft_prec):.3f} Soft Recall: {np.mean(derived_soft_rec):.3f} Soft F1: {np.mean(derived_soft_f1):.3f}")

    print("XXXXXXXX")
    print(f"HARD TABLES ({np.sum(is_hard)/3} DBs)")
    print("XXXXXXXX")
    hard_gt_sizes = [v for ind, v in enumerate(gt_sizes) if is_hard[ind] == 1]
    print(f"GT DP size: avg: {np.mean(hard_gt_sizes):.3f}")
    print(f"Predicted DP size avg: {np.mean([v for ind, v in enumerate(sizes) if is_hard[ind] == 1]):.3f}")
    print("- P/R/F1-")
    print(f"Precision: {np.mean([v for ind, v in enumerate(precisions) if is_hard[ind] == 1]):.3f}")
    print(f"Recall: {np.mean([v for ind, v in enumerate(recalls) if is_hard[ind] == 1]):.3f}")
    print(f"F1: {np.mean([v for ind, v in enumerate(f1s) if is_hard[ind] == 1]):.3f}")
    print("-")
    print("Including derived columnss:")
    print(f"GT DP size: avg: {np.mean([v for ind, v in enumerate(gt_all_relevant_sizes) if is_hard[ind] == 1]):.3f}")
    print(f"Predicted DP size avg: {np.mean([v for ind, v in enumerate(all_relevant_sizes) if is_hard[ind] == 1]):.3f}")
    print("- P/R/F1-")
    print(f"Precision: {np.mean([v for ind, v in enumerate(all_relevant_precisions) if is_hard[ind] == 1]):.3f}")
    print(f"Recall: {np.mean([v for ind, v in enumerate(all_relevant_recalls) if is_hard[ind] == 1]):.3f}")
    print(f"F1: {np.mean([v for ind, v in enumerate(all_relevant_f1s) if is_hard[ind] == 1]):.3f}")
    print("-")

    # print(f"{np.mean([v for ind,v in enumerate(precisions) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(recalls) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(f1s) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(all_relevant_precisions) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(all_relevant_recalls) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(all_relevant_f1s) if is_hard[ind]==1]):.3f}")
    if evaluate_derived_columns_soft_match:
        print(f"Derived column stats")
        print(
            f"Average similarity: {np.mean([v for ind, v in enumerate(macro_derived_sims) if is_hard[ind] == 1]):.3f}, Median diff count between ASTs: {np.median([v for ind, v in enumerate(macro_derived_diffs) if is_hard[ind] == 1]):.3f}")
        print(
            f"Soft Precision: {np.mean([v for ind, v in enumerate(derived_soft_prec) if is_hard[ind] == 1]):.3f} Soft Recall: {np.mean([v for ind, v in enumerate(derived_soft_rec) if is_hard[ind] == 1]):.3f} Soft F1: {np.mean([v for ind, v in enumerate(derived_soft_f1) if is_hard[ind] == 1]):.3f}")
    return {
        'pred_ratio': np.mean(sizes),
        'precision': np.mean(precisions),
        'recall': np.mean(recalls),
        'f1': np.mean(f1s),
        'include_derived_pred_ratio': np.mean(all_relevant_sizes),
        'include_derived_precision': np.mean(all_relevant_precisions),
        'include_derived_recall': np.mean(all_relevant_recalls),
        'include_derived_f1': np.mean(all_relevant_f1s),
        }

sql_exec_cache = {}
def eval_text2sql(data):
    with open((BENCH_DIR / "v7_hard_dp_bench_with_topics.json").resolve(), 'r') as f:
        hard_subset = json.load(f)
    hard_subset = set(hard_subset.keys())

    from benchmarks.dpbench_evaluation.sql_comparison import execute_sql
    correct_per_db = defaultdict(lambda: 0)
    total_per_db = defaultdict(lambda: 0)
    hard_correct_per_db = defaultdict(lambda: 0)
    hard_total_per_db = defaultdict(lambda: 0)
    for d in tqdm(data):
        gt = d['GT']
        pred = d['pred']
        db = d['database']
        if gt in sql_exec_cache:
            gt_res = sql_exec_cache[gt]
        else:
            gt_res = execute_sql(gt, db)
            sql_exec_cache[gt] = gt_res
        pred_res = execute_sql(pred, db)
        if gt_res == pred_res:
            correct_per_db[db] += 1
        total_per_db[db] += 1

        if db in hard_subset:

            if gt_res == pred_res:
                hard_correct_per_db[db] += 1
            hard_total_per_db[db] += 1
    all_corr = sum(list(correct_per_db.values()))
    total_count = sum(list(total_per_db.values()))
    hard_all_corr = sum(list(hard_correct_per_db.values()))
    hard_total_count = sum(list(hard_total_per_db.values()))
    print(f"{all_corr} out of {total_count} correct ({all_corr / total_count:.3f})")
    print(f"HARD: {hard_total_count} potentially runnable, {hard_all_corr} correct ({100*(hard_all_corr / hard_total_count):.3f}%) (out of 900 total questions: {100*(hard_all_corr / 900):.3f}%)")


if __name__ == "__main__":
    with open((BENCH_DIR / 'v7_dp_bench_with_topics.json').resolve(), 'r') as f:
        dpr_data = json.load(f)

    with open((SCHEMA_DIR / 'bird_train_tables.json').resolve(), 'r') as f:
        raw_schema_data = json.load(f)
    with open((SCHEMA_DIR / 'bird_dev_tables.json').resolve(), 'r') as f:
        raw_schema_data |= json.load(f)

    dp_result_file = 'v6_dpbench_baseline_gptoss_120b.pkl'
    with open((DATA_DIR / 'results' / dp_result_file).resolve(), 'rb') as f:
        experiment_res = pickle.load(f)
    print(f"Results for {dp_result_file}")
    calc_results(experiment_res, dpr_data, schema_data=raw_schema_data, evaluate_derived_columns_soft_match=False)

    text2sql_result_file = 'llama4_redo_gptoss_120v_text2sql.json'
    with open((DATA_DIR / 'results' / text2sql_result_file).resolve(), 'r') as f:
        text2sql_experiment_res = json.load(f)
    print(f"Results for {text2sql_result_file}")
    eval_text2sql(text2sql_experiment_res)