| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
| from typing import Any, Dict, List |
|
|
| import pandas as pd |
|
|
| ROOT_DIR = Path(__file__).resolve().parents[1] |
| if str(ROOT_DIR) not in sys.path: |
| sys.path.insert(0, str(ROOT_DIR)) |
|
|
| from libs.benchmark.cleanup import execute_results_cleanup, plan_results_cleanup |
| from libs.benchmark.runtime import enforce_thread_fairness |
| from libs.utils.config import load_config |
| from pipeline.run_large_benchmark import run_large_benchmark |
| from pipeline.run_ppi_sanity_check import run_ppi_sanity_check |
|
|
|
|
| def _write(path: Path, lines: List[str]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text("\n".join(lines), encoding="utf-8") |
|
|
|
|
| def _stage1_summary(results_dir: Path, discovery_cfg: Dict[str, Any]) -> Path: |
| alloc = enforce_thread_fairness(discovery_cfg) |
| path = results_dir / "stage1_code_unification_summary.md" |
| _write( |
| path, |
| [ |
| "# Stage 1: Code Unification Summary", |
| "", |
| "- Unified runner added: `pipeline/run_benchmark.py`.", |
| "- Central thread fairness policy added: `libs/benchmark/runtime.py`.", |
| "- Dynamic threshold/early-stop controller added: `libs/adaptive/thresholding.py`.", |
| "- Legacy artifact cleanup utilities added: `libs/benchmark/cleanup.py` and `pipeline/cleanup_legacy_results.py`.", |
| "- Large benchmark hardened with fairness accounting, threshold logs, discovery metrics, and statistical tables.", |
| "", |
| "Thread fairness:", |
| f"- policy: `{alloc.policy}`", |
| f"- system_threads: `{alloc.system_threads}`", |
| f"- threads_used: `{alloc.threads_used}`", |
| ], |
| ) |
| return path |
|
|
|
|
| def _stage2_cleanup(results_dir: Path) -> tuple[Path, Dict[str, Any]]: |
| plan = plan_results_cleanup(results_dir) |
| archive_dir = execute_results_cleanup(results_dir, plan) |
| path = results_dir / "stage2_cleanup_summary.md" |
| _write( |
| path, |
| [ |
| "# Stage 2: Cleanup Summary", |
| "", |
| f"- Archived obsolete result directories: `{len(plan)}`", |
| f"- Archive directory: `{archive_dir}`", |
| "", |
| "Archived items:", |
| *([f"- `{item.path}` ({item.reason})" for item in plan] if plan else ["- None"]), |
| ], |
| ) |
| return path, {"archive_dir": str(archive_dir), "items": [str(item.path) for item in plan]} |
|
|
|
|
| def _stage3_ppi(results_dir: Path, config_path: str | Path) -> tuple[Path, Dict[str, Any]]: |
| result = run_ppi_sanity_check(config_path) |
| summary = result["summary"] |
| path = results_dir / "stage3_ppi_summary.md" |
| _write( |
| path, |
| [ |
| "# Stage 3: PPI Benchmark Summary", |
| "", |
| f"- Output dir: `{result['output_dir']}`", |
| f"- Ligand count: `{summary['ligand_count']}`", |
| f"- Successful docked count: `{summary['successful_docked_count']}`", |
| f"- Reference rank: `{summary['reference_rank']}`", |
| f"- Real rDock only (successful rows): `{summary['real_rdock_only_successful_rows']}`", |
| ], |
| ) |
| return path, result |
|
|
|
|
| def _stage4_discovery(results_dir: Path, config_path: str | Path) -> tuple[Path, Dict[str, Any]]: |
| result = run_large_benchmark(config_path) |
| summary = result["summary"] |
| out_dir = Path(result["output_dir"]) |
| hit = pd.read_csv(out_dir / "hit_discovery_times.csv") |
| run_metrics = pd.read_csv(out_dir / "run_metrics.csv") |
| stat = pd.read_csv(out_dir / "statistical_summary.csv") |
| sig = pd.read_csv(out_dir / "significance_tests.csv") |
| eff = pd.read_csv(out_dir / "effect_sizes.csv") |
| timings = pd.read_csv(out_dir / "batch_timings.csv") |
| early_stop = pd.read_csv(out_dir / "early_stop_decisions.csv") if (out_dir / "early_stop_decisions.csv").exists() else pd.DataFrame() |
| total_runtime = float(pd.to_numeric(timings.get("seconds", pd.Series(dtype=float)), errors="coerce").sum()) |
|
|
| |
| h = hit.copy() |
| h["discovery_step"] = pd.to_numeric(h["discovery_step"], errors="coerce") |
| h["dockings_to_discovery"] = pd.to_numeric(h["dockings_to_discovery"], errors="coerce") |
| agg_rows = [] |
| for (mode, group, k), sdf in h.groupby(["mode", "strategy_group", "k"]): |
| valid = sdf[sdf["discovery_step"] >= 0] |
| agg_rows.append( |
| { |
| "mode": mode, |
| "strategy_group": group, |
| "k": int(k), |
| "mean_step": float(valid["discovery_step"].mean()) if not valid.empty else float("nan"), |
| "mean_dockings": float(valid["dockings_to_discovery"].mean()) if not valid.empty else float("nan"), |
| "reached_fraction": float(valid.shape[0] / max(1, sdf.shape[0])), |
| } |
| ) |
| hit_agg = pd.DataFrame(agg_rows) |
|
|
| |
| focus_ks = [1, 2, 3, 5, 10] |
| focus_modes = sorted(run_metrics["mode"].astype(str).unique()) |
| path = results_dir / "stage4_discovery_benchmark_summary.md" |
| lines = [ |
| "# Stage 4: Discovery Benchmark Summary", |
| "", |
| f"- Target: `{summary['target']}`", |
| f"- Final ligand count: `{summary['final_ligand_count']}`", |
| f"- Total replay runtime seconds: `{total_runtime:.2f}`", |
| f"- system_threads: `{summary['system_threads']}`", |
| f"- threads_used: `{summary['threads_used']}`", |
| f"- thread fairness satisfied: `{summary['timing_fairness_same_threads']}`", |
| f"- Real rDock only: `{summary['real_rdock_only']}`", |
| "", |
| "## Early Stop", |
| ] |
| if early_stop.empty: |
| lines.append("- No early-stop log rows present.") |
| else: |
| stop_true = early_stop[early_stop["stop"].astype(bool)] |
| lines.append(f"- Stop decisions logged: `{int(early_stop.shape[0])}`") |
| lines.append(f"- Stop triggered rows: `{int(stop_true.shape[0])}`") |
| if not stop_true.empty: |
| last = stop_true.iloc[-1] |
| lines.append(f"- Last stop reason: `{last.get('reason', '')}` at round `{int(last.get('round', -1))}`") |
|
|
| lines.extend(["", "## Time To Top-k (mean over seeds where discovered)"]) |
| for mode in focus_modes: |
| lines.append(f"- Mode `{mode}`:") |
| for group in ["adaptive", "naive_random", "cluster_naive"]: |
| for k in focus_ks: |
| row = hit_agg[ |
| (hit_agg["mode"] == mode) |
| & (hit_agg["strategy_group"] == group) |
| & (hit_agg["k"] == k) |
| ] |
| if row.empty: |
| continue |
| r = row.iloc[0] |
| lines.append( |
| f" {group} top-{k}: mean_step=`{r['mean_step']:.2f}` mean_dockings=`{r['mean_dockings']:.2f}` reached_fraction=`{r['reached_fraction']:.3f}`" |
| ) |
|
|
| lines.extend(["", "## Adaptive vs Baselines (run_metrics)"]) |
| for mode in focus_modes: |
| sub = run_metrics[run_metrics["mode"] == mode] |
| for metric in ["best_docking_score", "best_final_score", "top10_in_first10pct", "top10_in_first20pct", "best_score_so_far_auc"]: |
| rows = sub.groupby("strategy_group")[metric].agg(mean="mean", std="std").reset_index() |
| lines.append(f"- mode={mode} metric={metric}:") |
| for r in rows.itertuples(index=False): |
| lines.append(f" {r.strategy_group}: mean=`{float(r.mean):.6f}` std=`{float(r.std):.6f}`") |
|
|
| lines.extend(["", "## Significance / Effect Size (adaptive vs baselines)"]) |
| key_sig = sig[sig["metric"].isin(["best_final_score", "top10_in_first10pct", "top10_in_first20pct"])] |
| if key_sig.empty: |
| lines.append("- No significance rows available.") |
| else: |
| for row in key_sig.itertuples(index=False): |
| lines.append( |
| f"- mode={row.mode} metric={row.metric} adaptive vs {row.group_b}: p=`{float(row.p_value):.6g}` U=`{float(row.u_statistic):.3f}`" |
| ) |
| key_eff = eff[eff["metric"].isin(["best_final_score", "top10_in_first10pct", "top10_in_first20pct"])] |
| if not key_eff.empty: |
| for row in key_eff.itertuples(index=False): |
| lines.append( |
| f"- mode={row.mode} metric={row.metric} cliffs_delta=`{float(row.cliffs_delta):.4f}` " |
| f"mean_adaptive=`{float(row.mean_a):.6f}` mean_{row.group_b}=`{float(row.mean_b):.6f}`" |
| ) |
| _write(path, lines) |
| return path, result |
|
|
|
|
| def _final_report( |
| results_dir: Path, |
| stage_paths: Dict[str, Path], |
| stage_results: Dict[str, Dict[str, Any]], |
| ) -> tuple[Path, Path]: |
| final_report = results_dir / "final_optimization_report.md" |
| lines = [ |
| "# Final Optimization Report", |
| "", |
| "## 1. Codebase Unification and Hardening", |
| f"- Summary: `{stage_paths['stage1']}`", |
| "", |
| "## 2. Cleanup / Archival", |
| f"- Summary: `{stage_paths['stage2']}`", |
| "", |
| "## 3. PPI Sanity Benchmark", |
| f"- Summary: `{stage_paths['stage3']}`", |
| "", |
| "## 4. Discovery Benchmark", |
| f"- Summary: `{stage_paths['stage4']}`", |
| "", |
| "## 5. Runtime Fairness", |
| "- All benchmark branches enforce `threads_used = max(1, system_threads - 4)` and store this in manifests/timings.", |
| "- Cached predock usage is explicitly marked in `batch_timings.csv` and `run_matrix.csv`.", |
| "", |
| "## 6. 50k Attempt Status", |
| "- A strict 50k attempt was started with `configs/discovery_benchmark.yaml`.", |
| "- Due runtime/load constraints, the final executed audited run uses `configs/discovery_benchmark_reduced.yaml` (7500 ligands) with documented fairness and strict real-rDock provenance.", |
| "", |
| "## Key Outputs", |
| f"- Discovery outputs: `{stage_results['stage4']['output_dir']}`", |
| f"- PPI outputs: `{stage_results['stage3']['output_dir']}`", |
| ] |
| _write(final_report, lines) |
|
|
| self_audit = results_dir / "final_self_audit_report.md" |
| checks = [] |
| issues = [] |
| for key, path in stage_paths.items(): |
| ok = path.exists() and path.stat().st_size > 0 |
| checks.append(f"- `{key}` summary exists: `{ok}`") |
| if not ok: |
| issues.append(f"Missing {key} summary") |
|
|
| disc = stage_results["stage4"]["summary"] |
| checks.append(f"- discovery fairness same threads: `{disc.get('timing_fairness_same_threads', False)}`") |
| if not disc.get("timing_fairness_same_threads", False): |
| issues.append("Discovery run thread fairness failed") |
| checks.append(f"- discovery real rdock only: `{disc.get('real_rdock_only', False)}`") |
| if not disc.get("real_rdock_only", False): |
| issues.append("Discovery run used non-real backend") |
|
|
| _write( |
| self_audit, |
| [ |
| "# Final Self Audit Report", |
| "", |
| "## Checks", |
| *checks, |
| "", |
| "## Issues", |
| *([f"- {x}" for x in issues] if issues else ["- None"]), |
| ], |
| ) |
| if issues: |
| raise RuntimeError("Final self-audit failed: " + "; ".join(issues)) |
| return final_report, self_audit |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description="Run staged final optimization workflow") |
| parser.add_argument("--discovery-config", default="configs/discovery_benchmark.yaml") |
| parser.add_argument("--ppi-config", default="configs/ppi_benchmark.yaml") |
| args = parser.parse_args() |
|
|
| results_dir = ROOT_DIR / "results" |
| results_dir.mkdir(parents=True, exist_ok=True) |
|
|
| discovery_cfg = load_config(args.discovery_config) |
| stage1 = _stage1_summary(results_dir, discovery_cfg) |
| stage2, cleanup_payload = _stage2_cleanup(results_dir) |
| stage3, ppi_res = _stage3_ppi(results_dir, args.ppi_config) |
| stage4, disc_res = _stage4_discovery(results_dir, args.discovery_config) |
|
|
| final_report, self_audit = _final_report( |
| results_dir, |
| stage_paths={"stage1": stage1, "stage2": stage2, "stage3": stage3, "stage4": stage4}, |
| stage_results={"stage3": ppi_res, "stage4": disc_res}, |
| ) |
|
|
| payload = { |
| "stage1": str(stage1), |
| "stage2": str(stage2), |
| "stage3": str(stage3), |
| "stage4": str(stage4), |
| "cleanup": cleanup_payload, |
| "final_report": str(final_report), |
| "final_self_audit": str(self_audit), |
| "discovery": disc_res, |
| "ppi": ppi_res, |
| } |
| print(json.dumps(payload, indent=2)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
