| |
| """Cross-check final acquisition artifacts with existing inputs and fixed folds. |
| |
| Checks existing data only: no docking, acquisition loop, completion, or fitting. |
| The original CSV exporter used %.8g; comparisons respect that serialization. |
| """ |
| import argparse |
| from concurrent.futures import ThreadPoolExecutor |
| import csv |
| import io |
| import json |
| import math |
| from pathlib import Path |
| import tarfile |
|
|
| ALGORITHMS = ("surfdock", "unimol", "diffdock", "diffdock_l", "gnina", "autodock", "smina") |
|
|
|
|
| def rows(raw): |
| return list(csv.DictReader(io.StringIO(raw.decode()))) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1]) |
| p.add_argument("--report", type=Path) |
| args = p.parse_args() |
| root = args.root |
| truth_rows = rows((root / "data/targets/full_strict_score_matrix.csv").read_bytes()) |
| cost_rows = rows((root / "data/raw/moad_runtime_trimmed.csv").read_bytes()) |
| truth = {r["PDB_CCD_ID"]: {a: float(r[a + "_strict_score"]) for a in ALGORITHMS} for r in truth_rows} |
| costs = {r["PDB_CCD_ID"]: {a: float(r[a + "_runtime"]) for a in ALGORITHMS} for r in cost_rows} |
| split = rows((root / "data/splits/moad_5fold_split_seed42.csv").read_bytes()) |
| folds = {r["instance_id"]: int(r["test_fold"]) for r in split} |
| archives = sorted((root / "results/acquisition").glob("*/fold*_seed*.tar.xz")) |
|
|
| def compatible(actual, expected): |
| return math.isclose(float(actual), float("%.8g" % expected), rel_tol=1e-12, abs_tol=1e-14) |
|
|
| def check(path): |
| fold = int(path.name.split("_")[0][4:]) |
| seed = int(path.name.split("_")[1].split(".")[0][4:]) |
| expected = {x for x, f in folds.items() if f != fold} |
| wanted = {"strict_score_matrices/strict_score_100pct.csv", "queried_cells/cumulative/queried_100pct.csv"} |
| payload = {} |
| with tarfile.open(path, "r:xz") as tf: |
| for item in tf: |
| if item.name in wanted: |
| payload[item.name] = tf.extractfile(item).read() |
| matrix = rows(payload["strict_score_matrices/strict_score_100pct.csv"]) |
| ledger = rows(payload["queried_cells/cumulative/queried_100pct.csv"]) |
| ids = [r["PDB_CCD_ID"] for r in matrix] |
| if len(ids) != len(expected) or set(ids) != expected: |
| raise ValueError("Matrix training-fold membership mismatch: " + str(path)) |
| for r in matrix: |
| for a in ALGORITHMS: |
| if not compatible(r[a], truth[r["PDB_CCD_ID"]][a]): |
| raise ValueError("Full matrix differs from observed strict targets: " + str(path)) |
| n = len(expected) * len(ALGORITHMS) |
| cells = [(r["row_label"], r["algorithm"]) for r in ledger] |
| if len(cells) != n or len(set(cells)) != n or [int(r["query_order"]) for r in ledger] != list(range(1, n + 1)): |
| raise ValueError("Final ledger coverage/order mismatch: " + str(path)) |
| warm = [] |
| for r in ledger: |
| identity, a = r["row_label"], r["algorithm"] |
| if identity not in expected or a not in ALGORITHMS: |
| raise ValueError("Held-out or invalid cell in acquisition ledger") |
| if not compatible(r["score"], truth[identity][a]) or not compatible(r["runtime"], costs[identity][a]): |
| raise ValueError("Recorded outcome/runtime differs from raw inputs: " + str(path)) |
| if int(r["round"]) == 0: |
| warm.append((identity, a)) |
| return {"archive": str(path.relative_to(root)), "fold": fold, "seed": seed, |
| "training_complexes": len(ids), "observed_cells": n, "warm_start": warm} |
|
|
| with ThreadPoolExecutor(max_workers=4) as ex: |
| checked = list(ex.map(check, archives)) |
| signatures = {} |
| for r in checked: |
| key = (r["fold"], r["seed"]) |
| warm = r.pop("warm_start") |
| r["warm_start_cells"] = len(warm) |
| if key in signatures and signatures[key] != warm: |
| raise ValueError("Warm starts differ between policies for fold/seed " + str(key)) |
| signatures[key] = warm |
| if len(checked) != 90: |
| raise ValueError("Expected 90 runs") |
| report = {"status": "pass", "runs_checked": len(checked), |
| "full_matrices_match_existing_strict_targets": True, |
| "final_ledgers_cover_training_cells_exactly_once": True, |
| "held_out_cells_in_acquisition_ledgers": 0, |
| "recorded_scores_and_runtimes_match_inputs_at_export_precision": True, |
| "warm_starts_match_across_six_policies_for_every_fold_seed": True, |
| "new_experiments_executed": False, "details": checked} |
| if args.report: |
| args.report.write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps({k: v for k, v in report.items() if k != "details"}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
