#!/usr/bin/env python3 """Collect PPI baseline results into a Table 1 summary. Reads all results.json files from results/ppi_baselines/ and produces: - results/ppi/table1.csv -- full metrics table (model x split x negative) - results/ppi/table1.md -- Markdown formatted table (for paper draft) Usage: PYTHONPATH=src python scripts_ppi/collect_results.py PYTHONPATH=src python scripts_ppi/collect_results.py --results-dir results/ppi_baselines --out results/ppi PYTHONPATH=src python scripts_ppi/collect_results.py --dataset balanced --seed 42 PYTHONPATH=src python scripts_ppi/collect_results.py --aggregate-seeds --dataset balanced """ from __future__ import annotations import argparse import json import logging import sys from pathlib import Path import numpy as np import pandas as pd logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s") logger = logging.getLogger(__name__) ROOT = Path(__file__).parent.parent DEFAULT_DDB_REFERENCE = ROOT / "exports" / "ppi" / "ppi_m1_balanced_ddb.parquet" # Metrics to include in Table 1 (in display order) TABLE_METRICS = ["log_auc", "auprc", "bedroc", "ef_1pct", "ef_5pct", "mcc", "auroc"] TABLE_METRIC_NAMES = { "log_auc": "LogAUC", "auprc": "AUPRC", "bedroc": "BEDROC", "ef_1pct": "EF@1%", "ef_5pct": "EF@5%", "mcc": "MCC", "auroc": "AUROC", } # Display order for models/splits MODEL_ORDER = ["siamese_cnn", "pipr", "mlp_features"] SPLIT_ORDER = ["random", "cold_protein", "cold_both", "ddb"] NEG_ORDER = ["negbiodb", "uniform_random", "degree_matched"] def _canonical_run_name(model: str, dataset: str, split: str, negative: str, seed: int) -> str: return f"{model}_{dataset}_{split}_{negative}_seed{seed}" def _run_artifact_mtime_ns(run_dir: Path, results_json: Path) -> int: """Return the newest training artifact timestamp for a run directory.""" training_artifacts = [ run_dir / "best.pt", run_dir / "last.pt", run_dir / "training_log.csv", ] mtimes = [path.stat().st_mtime_ns for path in training_artifacts if path.exists()] if mtimes: return max(mtimes) return results_json.stat().st_mtime_ns def _drop_stale_ddb_results(df: pd.DataFrame, ddb_reference: Path | None) -> pd.DataFrame: """Drop DDB runs trained before the current DDB parquet existed.""" if ddb_reference is None or df.empty or not ddb_reference.exists(): return df ddb_mask = (df["dataset"] == "balanced") & (df["split"] == "ddb") if not ddb_mask.any(): return df reference_mtime_ns = ddb_reference.stat().st_mtime_ns stale_mask = ddb_mask & (df["_run_mtime_ns"] < reference_mtime_ns) if not stale_mask.any(): return df stale_paths = df.loc[stale_mask, "_results_path"].tolist() logger.warning( "Dropping %d stale DDB runs older than %s; retrain with regenerated DDB split.", int(stale_mask.sum()), ddb_reference, ) for path in stale_paths[:3]: logger.warning("Stale DDB run excluded: %s", path) return df.loc[~stale_mask].reset_index(drop=True) def load_results(results_dir: Path, ddb_reference: Path | None = None) -> pd.DataFrame: """Walk results_dir and load all results.json files.""" rows = [] for json_path in sorted(results_dir.glob("*/results.json")): try: with open(json_path) as f: data = json.load(f) except (json.JSONDecodeError, OSError) as e: logger.warning("Failed to read %s: %s", json_path, e) continue row: dict = { "model": data.get("model", "?"), "split": data.get("split", "?"), "negative": data.get("negative", "?"), "dataset": data.get("dataset", "?"), "seed": data.get("seed", -1), "n_train": data.get("n_train", 0), "n_val": data.get("n_val", 0), "n_test": data.get("n_test", 0), "best_val_log_auc": data.get("best_val_log_auc", float("nan")), "_run_name": data.get("run_name", ""), "_results_path": str(json_path), "_run_mtime_ns": _run_artifact_mtime_ns(json_path.parent, json_path), } metrics = data.get("test_metrics", {}) for m in TABLE_METRICS: row[m] = metrics.get(m, float("nan")) seed_value = row["seed"] if row["seed"] is not None else -1 row["_canonical_run_name"] = _canonical_run_name( row["model"], row["dataset"], row["split"], row["negative"], int(seed_value), ) rows.append(row) if not rows: logger.warning("No results.json files found in %s", results_dir) return pd.DataFrame() df = pd.DataFrame(rows) numeric_cols = ["seed", "n_train", "n_val", "n_test", "best_val_log_auc"] + TABLE_METRICS for col in numeric_cols: df[col] = pd.to_numeric(df[col], errors="coerce") df = _drop_stale_ddb_results(df, ddb_reference) if df.empty: return df df["_is_canonical_run_name"] = df["_run_name"] == df["_canonical_run_name"] dedup_cols = ["model", "dataset", "seed", "split", "negative"] df = df.sort_values( dedup_cols + ["_is_canonical_run_name", "_run_mtime_ns", "_results_path"], ascending=[True, True, True, True, True, False, False, False], ).reset_index(drop=True) duplicate_mask = df.duplicated(subset=dedup_cols, keep="first") if duplicate_mask.any(): logger.warning( "Dropping %d duplicate result rows; keeping canonical/newest.", int(duplicate_mask.sum()), ) df = df[~duplicate_mask].reset_index(drop=True) logger.info("Loaded %d result files.", len(df)) return df.drop(columns=["_run_name", "_results_path", "_run_mtime_ns", "_canonical_run_name", "_is_canonical_run_name"]) def filter_results( df: pd.DataFrame, dataset: str | None = None, seeds: list[int] | None = None, models: list[str] | None = None, splits: list[str] | None = None, negatives: list[str] | None = None, ) -> pd.DataFrame: """Filter collected results to a controlled subset.""" filtered = df.copy() if dataset is not None: filtered = filtered[filtered["dataset"] == dataset] if seeds: filtered = filtered[filtered["seed"].isin(seeds)] if models: filtered = filtered[filtered["model"].isin(models)] if splits: filtered = filtered[filtered["split"].isin(splits)] if negatives: filtered = filtered[filtered["negative"].isin(negatives)] return filtered.reset_index(drop=True) def build_table1(df: pd.DataFrame) -> pd.DataFrame: """Build Table 1: model x split x negative source with all metrics.""" model_cat = pd.CategoricalDtype(MODEL_ORDER + [m for m in df["model"].unique() if m not in MODEL_ORDER], ordered=True) split_cat = pd.CategoricalDtype(SPLIT_ORDER + [s for s in df["split"].unique() if s not in SPLIT_ORDER], ordered=True) neg_cat = pd.CategoricalDtype(NEG_ORDER + [n for n in df["negative"].unique() if n not in NEG_ORDER], ordered=True) df = df.copy() df["model"] = df["model"].astype(model_cat) df["split"] = df["split"].astype(split_cat) df["negative"] = df["negative"].astype(neg_cat) cols = ["model", "dataset", "seed", "split", "negative", "n_test"] + TABLE_METRICS return df[cols].sort_values(["model", "dataset", "seed", "split", "negative"]).reset_index(drop=True) def aggregate_over_seeds(df: pd.DataFrame) -> pd.DataFrame: """Aggregate metrics over seeds for identical experiment settings.""" if df.empty: return pd.DataFrame() group_cols = ["model", "dataset", "split", "negative"] agg_map: dict[str, list[str] | str] = { "seed": "nunique", "n_test": "mean", } for metric in TABLE_METRICS: agg_map[metric] = ["mean", "std"] grouped = df.groupby(group_cols, dropna=False).agg(agg_map) grouped.columns = [ "n_seeds" if col == ("seed", "nunique") else "n_test_mean" if col == ("n_test", "mean") else f"{col[0]}_{col[1]}" for col in grouped.columns.to_flat_index() ] grouped = grouped.reset_index() model_cat = pd.CategoricalDtype(MODEL_ORDER + [m for m in grouped["model"].unique() if m not in MODEL_ORDER], ordered=True) split_cat = pd.CategoricalDtype(SPLIT_ORDER + [s for s in grouped["split"].unique() if s not in SPLIT_ORDER], ordered=True) neg_cat = pd.CategoricalDtype(NEG_ORDER + [n for n in grouped["negative"].unique() if n not in NEG_ORDER], ordered=True) grouped["model"] = grouped["model"].astype(model_cat) grouped["split"] = grouped["split"].astype(split_cat) grouped["negative"] = grouped["negative"].astype(neg_cat) return grouped.sort_values(group_cols).reset_index(drop=True) def format_markdown(table: pd.DataFrame) -> str: """Format Table 1 as Markdown for the paper draft.""" lines: list[str] = [] metric_headers = " | ".join(f"**{TABLE_METRIC_NAMES[m]}**" for m in TABLE_METRICS) lines.append(f"| **Model** | **Dataset** | **Seed** | **Split** | **Negatives** | {metric_headers} |") lines.append("|" + "---|" * (5 + len(TABLE_METRICS))) for _, row in table.iterrows(): metric_vals = " | ".join( f"{row[m]:.3f}" if not np.isnan(row[m]) else "---" for m in TABLE_METRICS ) lines.append( f"| {row['model']} | {row['dataset']} | {row['seed']} | " f"{row['split']} | {row['negative']} | {metric_vals} |" ) return "\n".join(lines) def _fmt_mean_std(mean: float, std: float) -> str: """Format an aggregated metric as mean +/- std.""" if np.isnan(mean): return "---" if np.isnan(std): return f"{mean:.3f}" return f"{mean:.3f} +/- {std:.3f}" def format_aggregated_markdown(table: pd.DataFrame) -> str: """Format the seed-aggregated table as Markdown.""" lines: list[str] = [] metric_headers = " | ".join(f"**{TABLE_METRIC_NAMES[m]}**" for m in TABLE_METRICS) lines.append(f"| **Model** | **Dataset** | **Split** | **Negatives** | **Seeds** | {metric_headers} |") lines.append("|" + "---|" * (5 + len(TABLE_METRICS))) for _, row in table.iterrows(): metric_vals = " | ".join( _fmt_mean_std(row[f"{m}_mean"], row.get(f"{m}_std", float("nan"))) for m in TABLE_METRICS ) lines.append( f"| {row['model']} | {row['dataset']} | {row['split']} | " f"{row['negative']} | {int(row['n_seeds'])} | {metric_vals} |" ) return "\n".join(lines) def summarize_exp1(df: pd.DataFrame) -> str: """Compute inflation percentages for the abstract (Exp 1 key result).""" if df.empty: return "No Exp 1 results available." rows = _compute_exp1_summary_rows(df) lines = ["### Exp 1: NegBioDB vs. Random Negative Inflation"] current_dataset = None for row in rows: if row["dataset"] != current_dataset: current_dataset = row["dataset"] lines.append(f"Dataset={current_dataset}") if row["status"] != "ok": lines.append(f" {row['model']:15}: {row['status']}") continue lines.append( f" {row['model']:15}: NegBioDB={row['negbiodb_mean']:.3f} " f"uniform_random={row['uniform_random_mean']:.3f} (+{row['uniform_inflation']:.1f}%) " f"degree_matched={row['degree_matched_mean']:.3f} (+{row['degree_inflation']:.1f}%)" f" [n={row['n_seeds']}]" ) return "\n".join(lines) def _compute_exp1_summary_rows(df: pd.DataFrame) -> list[dict[str, object]]: """Compute matched-seed Exp 1 summaries from raw result rows.""" rows: list[dict[str, object]] = [] for dataset in sorted(df["dataset"].dropna().unique()): dataset_df = df[df["dataset"] == dataset] for model in MODEL_ORDER: m_df = dataset_df[dataset_df["model"] == model] if m_df.empty: continue required = ["negbiodb", "uniform_random", "degree_matched"] seed_sets = [] for negative in required: neg_df = m_df[m_df["negative"] == negative] if neg_df.empty: rows.append({"dataset": dataset, "model": model, "status": "incomplete"}) seed_sets = [] break seed_sets.append(set(neg_df["seed"].tolist())) if not seed_sets: continue common_seeds = set.intersection(*seed_sets) if not common_seeds: rows.append({"dataset": dataset, "model": model, "status": "no matched seeds"}) continue matched = m_df[m_df["seed"].isin(common_seeds)] stats = matched.groupby("negative", dropna=False)["log_auc"].agg(["mean", "std"]) neg_val = float(stats.loc["negbiodb", "mean"]) uni_val = float(stats.loc["uniform_random", "mean"]) deg_val = float(stats.loc["degree_matched", "mean"]) rows.append( { "dataset": dataset, "model": model, "status": "ok", "n_seeds": len(common_seeds), "negbiodb_mean": neg_val, "negbiodb_std": float(stats.loc["negbiodb", "std"]), "uniform_random_mean": uni_val, "uniform_random_std": float(stats.loc["uniform_random", "std"]), "degree_matched_mean": deg_val, "degree_matched_std": float(stats.loc["degree_matched", "std"]), "uniform_inflation": 100 * (uni_val - neg_val) / max(abs(neg_val), 1e-9), "degree_inflation": 100 * (deg_val - neg_val) / max(abs(neg_val), 1e-9), } ) return rows def summarize_exp1_aggregated(df: pd.DataFrame) -> str: """Summarize Exp1 inflation for aggregated reporting using matched raw seeds.""" if df.empty: return "No Exp 1 results available." rows = _compute_exp1_summary_rows(df) lines = ["### Exp 1: NegBioDB vs. Random Negative Inflation (Aggregated)"] current_dataset = None for row in rows: if row["dataset"] != current_dataset: current_dataset = row["dataset"] lines.append(f"Dataset={current_dataset}") if row["status"] != "ok": lines.append(f" {row['model']:15}: {row['status']}") continue lines.append( f" {row['model']:15}: " f"NegBioDB={_fmt_mean_std(row['negbiodb_mean'], row['negbiodb_std'])} " f"uniform_random={_fmt_mean_std(row['uniform_random_mean'], row['uniform_random_std'])}" f" (+{row['uniform_inflation']:.1f}%) " f"degree_matched={_fmt_mean_std(row['degree_matched_mean'], row['degree_matched_std'])}" f" (+{row['degree_inflation']:.1f}%) [n={row['n_seeds']}]" ) return "\n".join(lines) def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="Collect PPI baseline results into Table 1.") parser.add_argument("--results-dir", type=Path, default=ROOT / "results" / "ppi_baselines") parser.add_argument("--out", type=Path, default=ROOT / "results" / "ppi") parser.add_argument( "--dataset", choices=["balanced", "realistic"], help="Only include results for a single dataset", ) parser.add_argument( "--seed", type=int, action="append", dest="seeds", help="Only include runs for the given seed (repeatable)", ) parser.add_argument( "--model", action="append", dest="models", choices=MODEL_ORDER, help="Only include runs for the given model (repeatable)", ) parser.add_argument( "--split", action="append", dest="splits", choices=SPLIT_ORDER, help="Only include runs for the given split (repeatable)", ) parser.add_argument( "--negative", action="append", dest="negatives", choices=NEG_ORDER, help="Only include runs for the given negative source (repeatable)", ) parser.add_argument( "--aggregate-seeds", action="store_true", help="Also produce seed-aggregated tables (mean/std over seeds)", ) parser.add_argument( "--allow-stale-ddb", action="store_true", help="Include DDB runs older than exports/ppi/ppi_m1_balanced_ddb.parquet.", ) args = parser.parse_args(argv) ddb_reference = None if not args.allow_stale_ddb and DEFAULT_DDB_REFERENCE.exists(): ddb_reference = DEFAULT_DDB_REFERENCE df = load_results(args.results_dir, ddb_reference=ddb_reference) if df.empty: logger.error("No results found. Run training jobs first.") return 1 original_count = len(df) df = filter_results( df, dataset=args.dataset, seeds=args.seeds, models=args.models, splits=args.splits, negatives=args.negatives, ) if df.empty: logger.error("No results remain after filtering.") return 1 if len(df) != original_count: logger.info("Filtered results: %d -> %d rows", original_count, len(df)) table = build_table1(df) # Save CSV args.out.mkdir(parents=True, exist_ok=True) csv_path = args.out / "table1.csv" table.to_csv(csv_path, index=False) logger.info("Table 1 saved -> %s", csv_path) # Save Markdown md_path = args.out / "table1.md" md_content = format_markdown(table) md_path.write_text(md_content) logger.info("Table 1 Markdown saved -> %s", md_path) agg_table = None if args.aggregate_seeds: agg_table = aggregate_over_seeds(df) agg_csv_path = args.out / "table1_aggregated.csv" agg_table.to_csv(agg_csv_path, index=False) logger.info("Aggregated Table 1 saved -> %s", agg_csv_path) agg_md_path = args.out / "table1_aggregated.md" agg_md_path.write_text(format_aggregated_markdown(agg_table)) logger.info("Aggregated Table 1 Markdown saved -> %s", agg_md_path) # Print summary print("\n" + "=" * 60) print("PPI Table 1 Summary") print("=" * 60) print( table[["model", "dataset", "seed", "split", "negative", "log_auc", "auprc", "mcc"]] .to_string(index=False) ) print() # Exp 1 inflation analysis exp1_df = df[df["split"] == "random"] print(summarize_exp1(exp1_df)) if agg_table is not None: print() print("Aggregated Table 1 Summary") print("=" * 60) print( agg_table[["model", "dataset", "split", "negative", "n_seeds", "log_auc_mean", "log_auc_std", "auprc_mean", "mcc_mean"]] .to_string(index=False) ) print() print(summarize_exp1_aggregated(exp1_df)) print("=" * 60) logger.info("Done. %d completed runs.", len(table)) return 0 if __name__ == "__main__": sys.exit(main())