from __future__ import annotations import math import re from pathlib import Path import pandas as pd REPO_ROOT = Path(__file__).resolve().parents[2] EVAL_ROOT = REPO_ROOT / "Evaluation" OUT_DIR = EVAL_ROOT / "benchmark_overall_table" / "final" # README -> Figure Color Convention -> MODEL_COLORS PAPER_MODEL_ORDER = [ "real", "arf", "bayesnet", "ctgan", "forestdiffusion", "realtabformer", "tabbyflow", "tabddpm", "tabdiff", "tabpfgen", "tabsyn", "tvae", ] MODEL_LABELS = { "real": "REAL", "arf": "ARF", "bayesnet": "BayesNet", "ctgan": "CTGAN", "forestdiffusion": "ForestDiffusion", "realtabformer": "RealTabFormer", "tabbyflow": "TabbyFlow", "tabddpm": "TabDDPM", "tabdiff": "TabDiff", "tabpfgen": "TabPFGen", "tabsyn": "TabSyn", "tvae": "TVAE", } FINAL_BASENAME = "benchmark_overall_table_real" MODEL_ORDER_MAP = {model_id: idx for idx, model_id in enumerate(PAPER_MODEL_ORDER)} COMPUTED_METRICS = [ { "key": "distance_overall", "group": "Classical Fidelity", "title": "Dist. overall $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": True, "source_kind": "distance_dataset_export", "source_file": "Evaluation/distance/runs/*/datasets/*/distance_summary__*.csv", }, { "key": "jsd_distance", "group": "Classical Fidelity", "title": "JSD $\\downarrow$", "direction": "lower", "reference_value": 0.0, "highlight_column": False, "source_kind": "distance_dataset_export", "source_file": "Evaluation/distance/runs/*/datasets/*/distance_summary__*.csv", }, { "key": "ks_distance", "group": "Classical Fidelity", "title": "KS $\\downarrow$", "direction": "lower", "reference_value": 0.0, "highlight_column": False, "source_kind": "distance_dataset_export", "source_file": "Evaluation/distance/runs/*/datasets/*/distance_summary__*.csv", }, { "key": "tvd_distance", "group": "Classical Fidelity", "title": "TVD $\\downarrow$", "direction": "lower", "reference_value": 0.0, "highlight_column": False, "source_kind": "distance_dataset_export", "source_file": "Evaluation/distance/runs/*/datasets/*/distance_summary__*.csv", }, { "key": "wasserstein_distance", "group": "Classical Fidelity", "title": "Wasserstein $\\downarrow$", "direction": "lower", "reference_value": 0.0, "highlight_column": False, "source_kind": "distance_dataset_export", "source_file": "Evaluation/distance/runs/*/datasets/*/distance_summary__*.csv", }, { "key": "query_overall", "group": "Query-centric Families", "title": "Query overall $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": True, "source_kind": "derived_query_overall", "source_file": "Derived from the five query-centric family dataset-level scores in build_overall_benchmark_table.py.", }, { "key": "subgroup_structure", "group": "Query-centric Families", "title": "Subgroup $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": False, "source_kind": "query_family_dataset_export", "source_file": "Evaluation/query_fivepart_breakdown/subgroup_breakdown/data/dataset_model_scores.csv", }, { "key": "conditional_dependency_structure", "group": "Query-centric Families", "title": "Conditional $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": False, "source_kind": "query_family_dataset_export", "source_file": "Evaluation/query_fivepart_breakdown/conditional_breakdown/data/dataset_model_scores.csv", }, { "key": "tail_breakdown", "group": "Query-centric Families", "title": "Tail $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": False, "source_kind": "query_family_dataset_export", "source_file": "Evaluation/query_fivepart_breakdown/tail_breakdown/data/dataset_model_scores.csv", }, { "key": "missingness_structure", "group": "Query-centric Families", "title": "Missingness $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": False, "source_kind": "query_family_dataset_export", "source_file": "Evaluation/query_fivepart_breakdown/missingness_breakdown/data/dataset_model_scores.csv", }, { "key": "cardinality_structure", "group": "Query-centric Families", "title": "Cardinality $\\uparrow$", "direction": "higher", "reference_value": 1.0, "highlight_column": False, "source_kind": "cardinality_dataset_export", "source_file": "Evaluation/query_fivepart_breakdown/cardinality/data/cleaned_results.csv", }, ] PLACEHOLDER_COLUMNS = [ { "key": "train_time", "group": "Cost", "title": "Train time", "placeholder": True, }, { "key": "generation_time", "group": "Cost", "title": "Gen. time", "placeholder": True, }, ] DISPLAY_COLUMNS = COMPUTED_METRICS + PLACEHOLDER_COLUMNS METRIC_SPECS = {metric["key"]: metric for metric in COMPUTED_METRICS} DISPLAY_SPECS = {column["key"]: column for column in DISPLAY_COLUMNS} FAMILY_KEYS = [ "subgroup_structure", "conditional_dependency_structure", "tail_breakdown", "missingness_structure", "cardinality_structure", ] def ensure_out_dir() -> None: OUT_DIR.mkdir(parents=True, exist_ok=True) def dataset_prefix(dataset_id: str) -> str: return str(dataset_id)[0] if dataset_id else "" def dataset_sort_tuple(dataset_id: str) -> tuple[str, int, str]: text = str(dataset_id) match = re.match(r"([A-Za-z]+)(\d+)", text) if match: return match.group(1), int(match.group(2)), text return text, 0, text def latex_escape(text: str) -> str: replacements = { "\\": r"\textbackslash{}", "&": r"\&", "%": r"\%", "$": r"\$", "#": r"\#", "_": r"\_", "{": r"\{", "}": r"\}", "~": r"\textasciitilde{}", "^": r"\textasciicircum{}", } escaped = text for src, dst in replacements.items(): escaped = escaped.replace(src, dst) return escaped def fmt_num(value: float) -> str: if abs(value) < 5e-4: value = 0.0 return f"{value:.2f}" def normalize_long_metric( df: pd.DataFrame, metric_key: str, value_col: str, source_path: str, source_kind: str, ) -> pd.DataFrame: subset = df.copy() subset = subset[subset["model_id"].isin(PAPER_MODEL_ORDER)].copy() subset["model_label"] = subset["model_id"].map(MODEL_LABELS) subset["metric_key"] = metric_key subset["metric_group"] = METRIC_SPECS[metric_key]["group"] subset["metric_title"] = METRIC_SPECS[metric_key]["title"] subset["metric_value"] = subset[value_col] subset["source_kind"] = source_kind subset["source_path"] = source_path subset["row_kind"] = subset["model_id"].map(lambda model_id: "reference" if model_id == "real" else "synthetic") return subset[ [ "dataset_id", "dataset_prefix", "model_id", "model_label", "metric_key", "metric_group", "metric_title", "metric_value", "source_kind", "source_path", "row_kind", ] ] def load_distance_long() -> pd.DataFrame: frames = [] cols = [ "dataset_id", "model_id", "timestamp_utc", "jensen_shannon_distance", "kolmogorov_smirnov_distance", "total_variation_distance", "wasserstein_distance", "overall_fidelity_score", ] for path in (EVAL_ROOT / "distance" / "runs").glob("*/*/distance_summary__*.csv"): try: df = pd.read_csv(path, usecols=cols, low_memory=False) except Exception: continue frames.append(df) if not frames: raise FileNotFoundError("No distance dataset exports were found under Evaluation/distance/runs.") df = pd.concat(frames, ignore_index=True) df = df[df["model_id"].isin([model for model in PAPER_MODEL_ORDER if model != "real"])].copy() df["timestamp_utc"] = pd.to_datetime(df["timestamp_utc"], errors="coerce") df["dataset_prefix"] = df["dataset_id"].map(dataset_prefix) df = df.sort_values(["dataset_id", "model_id", "timestamp_utc"]).drop_duplicates( ["dataset_id", "model_id"], keep="last" ) metric_map = [ ("distance_overall", "overall_fidelity_score"), ("jsd_distance", "jensen_shannon_distance"), ("ks_distance", "kolmogorov_smirnov_distance"), ("tvd_distance", "total_variation_distance"), ("wasserstein_distance", "wasserstein_distance"), ] long_frames = [] for metric_key, value_col in metric_map: long_frames.append( normalize_long_metric( df[["dataset_id", "dataset_prefix", "model_id", value_col]].rename(columns={value_col: "metric_tmp"}), metric_key=metric_key, value_col="metric_tmp", source_path="distance_dataset_export_dedup_latest", source_kind="distance_dataset_export", ) ) return pd.concat(long_frames, ignore_index=True) def load_family_long() -> pd.DataFrame: frames = [] subgroup_path = EVAL_ROOT / "query_fivepart_breakdown" / "subgroup_breakdown" / "data" / "dataset_model_scores.csv" subgroup_df = pd.read_csv(subgroup_path) frames.append( normalize_long_metric( subgroup_df[["dataset_id", "dataset_prefix", "model_id", "subgroup_structure_score"]], metric_key="subgroup_structure", value_col="subgroup_structure_score", source_path=str(subgroup_path.relative_to(REPO_ROOT)), source_kind="query_family_dataset_export", ) ) conditional_path = EVAL_ROOT / "query_fivepart_breakdown" / "conditional_breakdown" / "data" / "dataset_model_scores.csv" conditional_df = pd.read_csv(conditional_path) frames.append( normalize_long_metric( conditional_df[["dataset_id", "dataset_prefix", "model_id", "conditional_dependency_structure_score"]], metric_key="conditional_dependency_structure", value_col="conditional_dependency_structure_score", source_path=str(conditional_path.relative_to(REPO_ROOT)), source_kind="query_family_dataset_export", ) ) tail_path = EVAL_ROOT / "query_fivepart_breakdown" / "tail_breakdown" / "data" / "dataset_model_scores.csv" tail_df = pd.read_csv(tail_path) frames.append( normalize_long_metric( tail_df[["dataset_id", "dataset_prefix", "model_id", "tail_breakdown_score"]], metric_key="tail_breakdown", value_col="tail_breakdown_score", source_path=str(tail_path.relative_to(REPO_ROOT)), source_kind="query_family_dataset_export", ) ) missing_path = EVAL_ROOT / "query_fivepart_breakdown" / "missingness_breakdown" / "data" / "dataset_model_scores.csv" missing_df = pd.read_csv(missing_path) frames.append( normalize_long_metric( missing_df[["dataset_id", "dataset_prefix", "model_id", "missingness_structure_score"]], metric_key="missingness_structure", value_col="missingness_structure_score", source_path=str(missing_path.relative_to(REPO_ROOT)), source_kind="query_family_dataset_export", ) ) cardinality_path = EVAL_ROOT / "query_fivepart_breakdown" / "cardinality" / "data" / "cleaned_results.csv" cardinality_raw = pd.read_csv( cardinality_path, low_memory=False, usecols=["dataset", "model", "official_cardinality_range_score"], ) cardinality_df = ( cardinality_raw.groupby(["dataset", "model"], as_index=False)["official_cardinality_range_score"].mean() .rename( columns={ "dataset": "dataset_id", "model": "model_id", "official_cardinality_range_score": "cardinality_structure_score", } ) ) cardinality_df["dataset_prefix"] = cardinality_df["dataset_id"].map(dataset_prefix) frames.append( normalize_long_metric( cardinality_df[["dataset_id", "dataset_prefix", "model_id", "cardinality_structure_score"]], metric_key="cardinality_structure", value_col="cardinality_structure_score", source_path=str(cardinality_path.relative_to(REPO_ROOT)), source_kind="cardinality_dataset_export", ) ) family_long = pd.concat(frames, ignore_index=True) return family_long[family_long["model_id"] != "real"].copy() def derive_query_overall_long(family_long: pd.DataFrame) -> pd.DataFrame: query_long = ( family_long[family_long["metric_key"].isin(FAMILY_KEYS)] .groupby(["dataset_id", "dataset_prefix", "model_id", "model_label"], as_index=False) .agg(metric_value=("metric_value", "mean")) ) query_long["metric_key"] = "query_overall" query_long["metric_group"] = METRIC_SPECS["query_overall"]["group"] query_long["metric_title"] = METRIC_SPECS["query_overall"]["title"] query_long["source_kind"] = METRIC_SPECS["query_overall"]["source_kind"] query_long["source_path"] = "derived_query_overall" query_long["row_kind"] = "synthetic" return query_long[ [ "dataset_id", "dataset_prefix", "model_id", "model_label", "metric_key", "metric_group", "metric_title", "metric_value", "source_kind", "source_path", "row_kind", ] ] def add_reference_rows(long_df: pd.DataFrame) -> pd.DataFrame: frames = [long_df] for metric in COMPUTED_METRICS: metric_key = metric["key"] metric_df = long_df[ (long_df["metric_key"] == metric_key) & long_df["metric_value"].notna() ].copy() if metric_df.empty: continue reference_rows = ( metric_df[["dataset_id", "dataset_prefix"]] .drop_duplicates() .assign( model_id="real", model_label="REAL", metric_key=metric_key, metric_group=metric["group"], metric_title=metric["title"], metric_value=metric["reference_value"], source_kind="real_self_reference", source_path="real_self_reference", row_kind="reference", ) ) frames.append(reference_rows) combined = pd.concat(frames, ignore_index=True) combined["model_order"] = combined["model_id"].map(MODEL_ORDER_MAP) return combined.sort_values( ["metric_key", "dataset_id", "model_order"], key=lambda col: col.map(dataset_sort_tuple) if col.name == "dataset_id" else col, ).reset_index(drop=True) def assemble_dataset_level_table() -> pd.DataFrame: distance_long = load_distance_long() family_long = load_family_long() query_overall_long = derive_query_overall_long(family_long) long_df = pd.concat([distance_long, family_long, query_overall_long], ignore_index=True) long_df = long_df[long_df["metric_value"].notna()].copy() long_df = add_reference_rows(long_df) return long_df[ [ "dataset_id", "dataset_prefix", "model_id", "model_label", "metric_key", "metric_group", "metric_title", "metric_value", "source_kind", "source_path", "row_kind", "model_order", ] ] def build_model_summary(dataset_level: pd.DataFrame) -> pd.DataFrame: grouped = ( dataset_level.groupby( ["model_id", "model_label", "row_kind", "metric_key", "metric_group", "metric_title"], as_index=False, ) .agg( metric_mean=("metric_value", "mean"), metric_std=("metric_value", "std"), metric_count=("metric_value", "count"), ) ) grouped.loc[grouped["metric_count"] <= 1, "metric_std"] = 0.0 wide = pd.DataFrame( { "model_id": PAPER_MODEL_ORDER, "model_label": [MODEL_LABELS[model_id] for model_id in PAPER_MODEL_ORDER], "row_kind": ["reference" if model_id == "real" else "synthetic" for model_id in PAPER_MODEL_ORDER], "model_order": [MODEL_ORDER_MAP[model_id] for model_id in PAPER_MODEL_ORDER], } ) for metric in COMPUTED_METRICS: metric_key = metric["key"] metric_rows = grouped[grouped["metric_key"] == metric_key][ ["model_id", "metric_mean", "metric_std", "metric_count"] ].rename( columns={ "metric_mean": f"{metric_key}_mean", "metric_std": f"{metric_key}_std", "metric_count": f"{metric_key}_count", } ) wide = wide.merge(metric_rows, on="model_id", how="left") for metric in COMPUTED_METRICS: metric_key = metric["key"] mean_col = f"{metric_key}_mean" rank_col = f"{metric_key}_rank" ascending = metric["direction"] == "lower" wide[rank_col] = pd.NA ranking = ( wide[(wide["row_kind"] == "synthetic") & wide[mean_col].notna()][["model_id", mean_col]] .sort_values(mean_col, ascending=ascending) .reset_index(drop=True) ) for idx, row in ranking.head(3).iterrows(): wide.loc[wide["model_id"] == row["model_id"], rank_col] = idx + 1 for placeholder in PLACEHOLDER_COLUMNS: key = placeholder["key"] wide[f"{key}_mean"] = pd.NA wide[f"{key}_std"] = pd.NA wide[f"{key}_count"] = pd.NA wide[f"{key}_rank"] = pd.NA return wide.sort_values("model_order").reset_index(drop=True) def render_cell_text(column_key: str, mean_value: float | None, std_value: float | None, rank: int | None) -> str: spec = DISPLAY_SPECS[column_key] prefix = r"\cellcolor{OverallTint} " if spec.get("highlight_column") else "" if spec.get("placeholder"): return prefix + "" if pd.isna(mean_value): return prefix + r"\textit{N/A}" std_numeric = 0.0 if pd.isna(std_value) else float(std_value) body = f"{fmt_num(float(mean_value))}$_{{\\pm {fmt_num(std_numeric)}}}$" rank_value = None if pd.isna(rank) else int(rank) if rank_value == 1: body = rf"{{\color{{FirstPlace}}\textbf{{{body}}}}}" elif rank_value == 2: body = rf"{{\color{{SecondPlace}}\textbf{{{body}}}}}" elif rank_value == 3: body = rf"{{\color{{ThirdPlace}}\textbf{{{body}}}}}" return prefix + body def build_header_cells(group_name: str) -> list[dict[str, object]]: return [column for column in DISPLAY_COLUMNS if column["group"] == group_name] def render_latex(summary: pd.DataFrame) -> str: row_lines = [] for _, row in summary.iterrows(): cells = [latex_escape(str(row["model_label"]))] for column in DISPLAY_COLUMNS: key = column["key"] cells.append(render_cell_text(key, row.get(f"{key}_mean"), row.get(f"{key}_std"), row.get(f"{key}_rank"))) row_lines.append(" & ".join(cells) + r" \\") classical_cols = build_header_cells("Classical Fidelity") query_cols = build_header_cells("Query-centric Families") cost_cols = build_header_cells("Cost") total_cols = 1 + len(DISPLAY_COLUMNS) tabular_spec = "@{}l " + " ".join("c" for _ in DISPLAY_COLUMNS) + "@{}" header_cells = [] for column in DISPLAY_COLUMNS: title = column["title"] if column.get("highlight_column"): header_cells.append(rf"\cellcolor{{OverallTint}} {title}") else: header_cells.append(title) return rf"""\documentclass[10pt]{{article}} \usepackage[a4paper,landscape,margin=0.60in]{{geometry}} \usepackage[T1]{{fontenc}} \usepackage[utf8]{{inputenc}} \usepackage{{newtxtext,newtxmath}} \usepackage{{booktabs}} \usepackage[table]{{xcolor}} \usepackage{{array}} \usepackage{{multirow}} \usepackage{{caption}} \usepackage{{microtype}} \usepackage{{graphicx}} \captionsetup{{font=small,labelfont=bf}} \definecolor{{FirstPlace}}{{HTML}}{{1397B8}} \definecolor{{SecondPlace}}{{HTML}}{{7B45E5}} \definecolor{{ThirdPlace}}{{HTML}}{{F28E2B}} \definecolor{{OverallTint}}{{HTML}}{{F8F1DA}} \definecolor{{RuleGray}}{{HTML}}{{C8CDD3}} \arrayrulecolor{{RuleGray}} \setlength{{\tabcolsep}}{{4.0pt}} \renewcommand{{\arraystretch}}{{1.12}} \begin{{document}} \thispagestyle{{empty}} \noindent{{\small\textit{{Conference-style benchmark summary for the evaluation section}}}}\\[-0.15em] \noindent\color{{RuleGray}}\rule{{\textwidth}}{{0.5pt}} \begin{{table}}[ht] \centering \caption{{Benchmark-wide summary of the frozen paper-facing model set specified in the README figure convention: 11 synthetic generators plus the \texttt{{REAL}} reference row. We report mean $\pm$ std across covered datasets using the current materialized evaluation exports. Lower is better for the four raw classical distance columns; higher is better for the two overall columns and the five query-centric family scores. The {{\color{{FirstPlace}} First}}, {{\color{{SecondPlace}} Second}}, and {{\color{{ThirdPlace}} Third}} best synthetic-model values in each column are highlighted with the same colors used in the table.}} \label{{tab:benchmark_overall_real}} \footnotesize \resizebox{{\textwidth}}{{!}}{{% \begin{{tabular}}{{{tabular_spec}}} \toprule \multirow{{2}}{{*}}{{\textbf{{Generator}}}} & \multicolumn{{{len(classical_cols)}}}{{c}}{{\textbf{{Classical Fidelity}}}} & \multicolumn{{{len(query_cols)}}}{{c}}{{\textbf{{Query-centric Families}}}} & \multicolumn{{{len(cost_cols)}}}{{c}}{{\textbf{{Cost}}}} \\ \cmidrule(lr){{2-{1 + len(classical_cols)}}} \cmidrule(lr){{{2 + len(classical_cols)}-{1 + len(classical_cols) + len(query_cols)}}} \cmidrule(lr){{{2 + len(classical_cols) + len(query_cols)}-{total_cols}}} & {" & ".join(header_cells)} \\ \midrule {chr(10).join(row_lines)} \bottomrule \end{{tabular}}% }} \vspace{{0.45em}} \begin{{minipage}}{{0.95\linewidth}} \small \textit{{Note.}} The \texttt{{REAL}} row is a self-comparison reference row. For raw distance columns it is fixed to 0.00; for \texttt{{Dist. overall}}, \texttt{{Query overall}}, and the five family-score columns it is fixed to 1.00. The cost columns are intentionally left blank as placeholders for the training-time and generation-time statistics that will be added next. \end{{minipage}} \end{{table}} \end{{document}} """ def build_source_manifest() -> pd.DataFrame: rows = [] for metric in COMPUTED_METRICS: rows.append( { "metric_key": metric["key"], "metric_group": metric["group"], "metric_title": metric["title"], "source_kind": metric["source_kind"], "source_file": metric["source_file"], } ) for placeholder in PLACEHOLDER_COLUMNS: rows.append( { "metric_key": placeholder["key"], "metric_group": placeholder["group"], "metric_title": placeholder["title"], "source_kind": "placeholder", "source_file": "Reserved placeholder column; real values will be added later.", } ) rows.append( { "metric_key": "real_reference_rows", "metric_group": "Reference", "metric_title": "REAL self-comparison rows", "source_kind": "derived_reference", "source_file": "Generated in build_overall_benchmark_table.py from the applicable dataset coverage of each metric.", } ) return pd.DataFrame(rows) def write_outputs(dataset_level: pd.DataFrame, summary: pd.DataFrame) -> None: ensure_out_dir() dataset_csv_path = OUT_DIR / f"{FINAL_BASENAME}_dataset_level.csv" summary_csv_path = OUT_DIR / f"{FINAL_BASENAME}_model_summary.csv" sources_csv_path = OUT_DIR / f"{FINAL_BASENAME}_sources.csv" tex_path = OUT_DIR / f"{FINAL_BASENAME}.tex" dataset_level.to_csv(dataset_csv_path, index=False) summary.to_csv(summary_csv_path, index=False) build_source_manifest().to_csv(sources_csv_path, index=False) tex_path.write_text(render_latex(summary), encoding="utf-8") def main() -> None: dataset_level = assemble_dataset_level_table() summary = build_model_summary(dataset_level) write_outputs(dataset_level, summary) if __name__ == "__main__": main()