| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| from pathlib import Path |
| from typing import Any |
|
|
| from .audit_benchmark import audit_benchmark_run |
| from .provenance import require_file |
| from .validate_fidelity import validate_fidelity |
|
|
|
|
| def _read_rows(path: str | Path) -> list[dict[str, str]]: |
| with require_file(path, "benchmark table").open("r", encoding="utf-8", newline="") as handle: |
| return list(csv.DictReader(handle)) |
|
|
|
|
| def _float(value: object, default: float | None = None) -> float | None: |
| try: |
| text = str(value).strip() |
| if not text: |
| return default |
| return float(text) |
| except Exception: |
| return default |
|
|
|
|
| def _score(row: dict[str, Any], *keys: str) -> float | None: |
| for key in keys: |
| value = _float(row.get(key), None) |
| if value is not None and math.isfinite(value): |
| return value |
| return None |
|
|
|
|
| def _mean(values: list[float]) -> float: |
| return sum(values) / len(values) if values else 0.0 |
|
|
|
|
| def _spearman(xs: list[float], ys: list[float]) -> float | None: |
| if len(xs) < 2 or len(xs) != len(ys): |
| return None |
|
|
| def _ranks(values: list[float]) -> list[float]: |
| order = sorted(range(len(values)), key=lambda i: values[i]) |
| ranks = [0.0] * len(values) |
| for rank, idx in enumerate(order, start=1): |
| ranks[idx] = float(rank) |
| return ranks |
|
|
| rx = _ranks(xs) |
| ry = _ranks(ys) |
| mx = _mean(rx) |
| my = _mean(ry) |
| num = sum((a - mx) * (b - my) for a, b in zip(rx, ry)) |
| denx = math.sqrt(sum((a - mx) ** 2 for a in rx)) |
| deny = math.sqrt(sum((b - my) ** 2 for b in ry)) |
| if denx == 0.0 or deny == 0.0: |
| return None |
| return num / (denx * deny) |
|
|
|
|
| def _ensure_matplotlib(): |
| try: |
| import matplotlib |
|
|
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| except Exception: |
| return None |
| return plt |
|
|
|
|
| def _write_json(path: Path, payload: dict[str, Any]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(payload, indent=2), encoding="utf-8") |
|
|
|
|
| def _validation_plots(run_dir: Path, metrics: dict[str, Any]) -> list[str]: |
| plt = _ensure_matplotlib() |
| plot_dir = run_dir / "plots" |
| plot_dir.mkdir(parents=True, exist_ok=True) |
| out: list[str] = [] |
| if plt is None: |
| return out |
|
|
| trace_rows = _read_rows(run_dir / "tables" / "multifidelity_trace.csv") if (run_dir / "tables" / "multifidelity_trace.csv").exists() else [] |
| final_filtered = _read_rows(run_dir / "tables" / "final_hits_filtered.csv") if (run_dir / "tables" / "final_hits_filtered.csv").exists() else [] |
| random_rows = _read_rows(run_dir / "tables" / "random_baseline_scores.csv") if (run_dir / "tables" / "random_baseline_scores.csv").exists() else [] |
| single_rows = _read_rows(run_dir / "tables" / "single_fidelity_adaptive_scores.csv") if (run_dir / "tables" / "single_fidelity_adaptive_scores.csv").exists() else [] |
|
|
| def save(fig, name: str) -> None: |
| path = plot_dir / name |
| fig.tight_layout() |
| fig.savefig(path, dpi=160) |
| plt.close(fig) |
| out.append(str(path)) |
|
|
| |
| fig, ax = plt.subplots(figsize=(7, 4)) |
| labels = ["adaptive", "random", "single"] |
| vals = [ |
| float(metrics.get("multifidelity_total_runs_spent") or 0.0), |
| float(metrics.get("random_total_runs_spent") or 0.0), |
| float(metrics.get("single_fidelity_total_runs_spent") or 0.0), |
| ] |
| ax.bar(labels, vals, color=["#3b6ea8", "#bf7f2f", "#7a4f9d"]) |
| ax.set_title("Cost balance comparison across benchmark strategies") |
| ax.set_xlabel("Strategy") |
| ax.set_ylabel("Total rDock runs spent") |
| save(fig, "cost_balance_comparison.png") |
|
|
| |
| fig, ax = plt.subplots(figsize=(8, 4)) |
| ks = [1, 5, 10, 20] |
| series = {} |
| for name, rows in { |
| "adaptive": final_filtered, |
| "random": random_rows, |
| "single": single_rows, |
| }.items(): |
| ranked = sorted( |
| [row for row in rows if _score(row, "final_score", "SCORE") is not None], |
| key=lambda row: _score(row, "final_score", "SCORE") or float("inf"), |
| ) |
| series[name] = [_mean([_score(row, "final_score", "SCORE") or 0.0 for row in ranked[:k]]) if ranked[:k] else math.nan for k in ks] |
| for idx, (name, vals_) in enumerate(series.items()): |
| ax.plot(ks, vals_, marker="o", linewidth=2, label=name) |
| ax.set_title("Top-k filtered score comparison by strategy") |
| ax.set_xlabel("k") |
| ax.set_ylabel("Mean filtered docking SCORE") |
| ax.legend() |
| save(fig, "topk_filtered_score_comparison.png") |
|
|
| |
| pred_obs = [] |
| unc_err = [] |
| for row in trace_rows: |
| pred = _score(row, "pre_docking_predicted_score", "predicted_filtered_score") |
| obs = _score(row, "ranking_score", "SCORE") |
| unc = _score(row, "pre_docking_predicted_uncertainty", "predicted_uncertainty") |
| if pred is not None and obs is not None: |
| if _score(row, "pre_docking_predicted_score") is None and _score(row, "predicted_uncertainty") == 0.0: |
| continue |
| pred_obs.append((pred, obs)) |
| if unc is not None: |
| unc_err.append((unc, abs(pred - obs))) |
| if pred_obs: |
| fig, ax = plt.subplots(figsize=(5, 5)) |
| xs = [item[0] for item in pred_obs] |
| ys = [item[1] for item in pred_obs] |
| ax.scatter(xs, ys, alpha=0.7, color="#3b6ea8") |
| lo = min(xs + ys) |
| hi = max(xs + ys) |
| ax.plot([lo, hi], [lo, hi], linestyle="--", color="gray") |
| ax.set_title("Surrogate calibration: predicted vs observed score") |
| ax.set_xlabel("Predicted filtered score") |
| ax.set_ylabel("Observed docking score") |
| save(fig, "surrogate_calibration.png") |
| if unc_err: |
| fig, ax = plt.subplots(figsize=(5, 4)) |
| xs = [item[0] for item in unc_err] |
| ys = [item[1] for item in unc_err] |
| ax.scatter(xs, ys, alpha=0.7, color="#7a4f9d") |
| ax.set_title("Surrogate uncertainty versus absolute error") |
| ax.set_xlabel("Predicted uncertainty") |
| ax.set_ylabel("Absolute prediction error") |
| save(fig, "surrogate_uncertainty_vs_error.png") |
|
|
| |
| if trace_rows: |
| fig, ax = plt.subplots(figsize=(7, 4)) |
| seen = set() |
| xs: list[int] = [] |
| ys: list[int] = [] |
| for idx, row in enumerate(sorted(trace_rows, key=lambda r: (int(float(r.get("batch_id") or 0.0)), int(float(r.get("selected_fidelity_runs") or 0.0)))), start=1): |
| seen.add(str(row.get("cluster_id", ""))) |
| xs.append(idx) |
| ys.append(len(seen)) |
| ax.plot(xs, ys, color="#3b6ea8") |
| ax.set_title("Cluster diversity over adaptive screening time") |
| ax.set_xlabel("Processed multifidelity records") |
| ax.set_ylabel("Unique clusters seen") |
| save(fig, "cluster_diversity_over_time.png") |
|
|
| return out |
|
|
|
|
| def validate_benchmark_model(run_dir: str | Path) -> dict[str, Any]: |
| root = Path(run_dir) |
| audit = audit_benchmark_run(root) |
| fidelity = validate_fidelity(root) |
| metrics = dict(audit["metrics"]) |
| comparability = dict(audit["comparability_audit"]) |
| trace_rows = _read_rows(root / "tables" / "multifidelity_trace.csv") if (root / "tables" / "multifidelity_trace.csv").exists() else [] |
| raw_rows = _read_rows(root / "tables" / "final_hits_raw.csv") if (root / "tables" / "final_hits_raw.csv").exists() else [] |
| filtered_rows = _read_rows(root / "tables" / "final_hits_filtered.csv") if (root / "tables" / "final_hits_filtered.csv").exists() else [] |
|
|
| pred = [] |
| obs = [] |
| unc = [] |
| abs_err = [] |
| for row in trace_rows: |
| predicted = _score(row, "pre_docking_predicted_score", "predicted_filtered_score") |
| observed = _score(row, "ranking_score", "SCORE") |
| uncertainty = _score(row, "pre_docking_predicted_uncertainty", "predicted_uncertainty") |
| if predicted is not None and observed is not None: |
| if _score(row, "pre_docking_predicted_score") is None and _score(row, "predicted_uncertainty") == 0.0: |
| continue |
| pred.append(predicted) |
| obs.append(observed) |
| abs_err.append(abs(predicted - observed)) |
| if uncertainty is not None: |
| unc.append((uncertainty, abs(predicted - observed))) |
|
|
| mae = _mean(abs_err) if abs_err else None |
| spearman = _spearman(pred, obs) |
| uncertainty_spearman = _spearman([x for x, _ in unc], [y for _, y in unc]) if unc else None |
| raw_ids = {str(row.get("ligand_id", "")) for row in raw_rows} |
| filtered_ids = {str(row.get("ligand_id", "")) for row in filtered_rows} |
| dropped_raw = len(raw_ids - filtered_ids) |
|
|
| validation_metrics = { |
| "run_dir": str(root), |
| "benchmark_status": metrics.get("benchmark_status"), |
| "comparable": comparability.get("comparable"), |
| "cost_ratio_random_vs_multifidelity": comparability.get("cost_ratio_random_vs_multifidelity"), |
| "cost_ratio_single_vs_multifidelity": comparability.get("cost_ratio_single_vs_multifidelity"), |
| "filter_retention_fraction": (len(filtered_rows) / len(raw_rows)) if raw_rows else 0.0, |
| "raw_hits_dropped_after_filtering": dropped_raw, |
| "surrogate_mae": mae, |
| "surrogate_spearman": spearman, |
| "uncertainty_vs_error_spearman": uncertainty_spearman, |
| "n_surrogate_points": len(pred), |
| "fidelity_reliability": fidelity, |
| "reasons": comparability.get("reasons", []), |
| } |
| if spearman is None or spearman <= 0.0: |
| validation_metrics.setdefault("warnings", []).append("MODEL DOES NOT PROVIDE USEFUL RANKING SIGNAL YET") |
| if not fidelity.get("low_fidelity_reliable", True): |
| validation_metrics.setdefault("warnings", []).append("LOW FIDELITY IS NOT RELIABLE ENOUGH FOR AGGRESSIVE PRUNING") |
| plots = _validation_plots(root, metrics) |
| _write_json(root / "metrics" / "validation_metrics.json", validation_metrics) |
| report_lines = [ |
| f"# validation_report: {root.name}", |
| "", |
| f"- comparable: `{validation_metrics['comparable']}`", |
| f"- benchmark_status: `{validation_metrics['benchmark_status']}`", |
| f"- cost_ratio_random_vs_multifidelity: `{validation_metrics['cost_ratio_random_vs_multifidelity']}`", |
| f"- cost_ratio_single_vs_multifidelity: `{validation_metrics['cost_ratio_single_vs_multifidelity']}`", |
| f"- filter_retention_fraction: `{validation_metrics['filter_retention_fraction']}`", |
| f"- raw_hits_dropped_after_filtering: `{validation_metrics['raw_hits_dropped_after_filtering']}`", |
| f"- surrogate_mae: `{validation_metrics['surrogate_mae']}`", |
| f"- surrogate_spearman: `{validation_metrics['surrogate_spearman']}`", |
| f"- uncertainty_vs_error_spearman: `{validation_metrics['uncertainty_vs_error_spearman']}`", |
| f"- low_fidelity_reliable: `{fidelity.get('low_fidelity_reliable')}`", |
| ] |
| for warning in validation_metrics.get("warnings", []): |
| report_lines.append(f"- warning: `{warning}`") |
| for reason in validation_metrics["reasons"]: |
| report_lines.append(f"- reason: `{reason}`") |
| report_lines.extend(["", "## Diagnostic Plots"]) |
| for path in plots: |
| report_lines.append(f"- `{path}`") |
| (root / "validation_report.md").write_text("\n".join(report_lines) + "\n", encoding="utf-8") |
| return {"validation_metrics": validation_metrics, "validation_report": str(root / "validation_report.md"), "plots": plots} |
|
|
|
|
| def build_arg_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description="Validate an existing adaptive benchmark run and generate diagnostic plots.") |
| parser.add_argument("--run-dir", required=True) |
| return parser |
|
|
|
|
| def run_from_args(args: argparse.Namespace) -> dict[str, Any]: |
| return validate_benchmark_model(args.run_dir) |
|
|
|
|
| def main() -> int: |
| parser = build_arg_parser() |
| args = parser.parse_args() |
| print(json.dumps(run_from_args(args), indent=2)) |
| return 0 |
|
|
