| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| import traceback |
| from pathlib import Path |
| from typing import Any |
|
|
| from .config_io import dump_json_like, load_structured_file |
| from .dataset import repair_dataset_dir |
| from .provenance import RDockPipelineError, require_file |
| from .rdock import TargetConfig, load_target_config |
| from .sdf import write_rows_csv |
|
|
|
|
| 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 _load_json_if_exists(path: str | Path) -> dict[str, Any]: |
| candidate = Path(path) |
| if not candidate.exists(): |
| return {} |
| try: |
| payload = json.loads(candidate.read_text(encoding="utf-8")) |
| except Exception: |
| return {} |
| return payload if isinstance(payload, dict) else {} |
|
|
|
|
| def _load_struct_if_exists(path: str | Path) -> dict[str, Any]: |
| candidate = Path(path) |
| if not candidate.exists(): |
| return {} |
| try: |
| return load_structured_file(candidate) |
| except Exception: |
| return {} |
|
|
|
|
| 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 _finite(value: object) -> float | None: |
| out = _float(value, None) |
| if out is None or not math.isfinite(out): |
| return None |
| return out |
|
|
|
|
| def _score_from_row(row: dict[str, Any], *keys: str) -> float | None: |
| for key in keys: |
| value = _finite(row.get(key)) |
| if value is not None: |
| return value |
| return None |
|
|
|
|
| def _boolish(value: object) -> bool: |
| return str(value).strip().lower() in {"1", "true", "yes", "y"} |
|
|
|
|
| def _mean(values: list[float]) -> float: |
| return sum(values) / len(values) if values else 0.0 |
|
|
|
|
| def _stdev(values: list[float], center: float) -> float: |
| if not values: |
| return 1.0 |
| variance = sum((value - center) ** 2 for value in values) / max(1, len(values)) |
| return math.sqrt(variance) or 1.0 |
|
|
|
|
| def _sort_by_score(rows: list[dict[str, Any]], *keys: str) -> list[dict[str, Any]]: |
| return sorted( |
| rows, |
| key=lambda row: ( |
| _score_from_row(row, *keys) if _score_from_row(row, *keys) is not None else float("inf"), |
| str(row.get("ligand_id", "")), |
| ), |
| ) |
|
|
|
|
| def _augment_full_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]: |
| success_rows = [row for row in rows if str(row.get("rdock_success", "true")).lower() in {"true", "1", ""} and _score_from_row(row, "best_score", "SCORE", "final_score") is not None] |
| ordered = _sort_by_score(success_rows, "best_score", "SCORE", "final_score") |
| total = max(1, len(ordered)) |
| enriched: list[dict[str, Any]] = [] |
| for idx, row in enumerate(ordered, start=1): |
| item = dict(row) |
| percentile = 100.0 if total == 1 else 100.0 * (1.0 - ((idx - 1) / (total - 1))) |
| item["full_rank"] = idx |
| item["rank_vs_full"] = idx |
| item["full_percentile"] = percentile |
| item["percentile_vs_full"] = percentile |
| enriched.append(item) |
| return enriched |
|
|
|
|
| def _normalize_target_config(cfg: TargetConfig) -> dict[str, Any]: |
| return { |
| "receptor_name": Path(cfg.receptor).name, |
| "reference_ligand_name": Path(cfg.reference_ligand).name, |
| "receptor_mol2_name": Path(cfg.receptor_mol2).name, |
| "receptor_prm_name": Path(cfg.receptor_prm).name, |
| "cavity_as_name": Path(cfg.cavity_as).name, |
| "pocket_center": [round(float(value), 4) for value in cfg.pocket_center], |
| "pocket_radius": round(float(cfg.pocket_radius), 4), |
| } |
|
|
|
|
| def _same_target_config(run_dir: Path, dataset_dir: Path | None) -> tuple[bool, list[str]]: |
| reasons: list[str] = [] |
| root_cfg_path = run_dir / "target" / "rdock_prm" / "target_config.yaml" |
| if not root_cfg_path.exists(): |
| reasons.append("missing run target_config.yaml") |
| return False, reasons |
| root_cfg = _normalize_target_config(load_target_config(root_cfg_path)) |
| if dataset_dir is None: |
| reasons.append("dataset_dir unavailable") |
| return False, reasons |
| dataset_cfg_path = dataset_dir / "target" / "rdock_prm" / "target_config.yaml" |
| if not dataset_cfg_path.exists(): |
| reasons.append("missing dataset target_config.yaml") |
| return False, reasons |
| dataset_cfg = _normalize_target_config(load_target_config(dataset_cfg_path)) |
| if root_cfg != dataset_cfg: |
| reasons.append("run target_config differs from dataset target_config") |
| return False, reasons |
| return True, reasons |
|
|
|
|
| def _apply_component_flags( |
| rows: list[dict[str, Any]], |
| score_z_threshold: float = 5.0, |
| intra_z_threshold: float = 4.0, |
| max_intra_fraction_soft: float = 0.75, |
| max_intra_fraction_hard: float = 0.9, |
| ) -> list[dict[str, Any]]: |
| score_values = [_score_from_row(row, "final_score", "SCORE") for row in rows] |
| score_values = [value for value in score_values if value is not None] |
| intra_values = [_score_from_row(row, "SCORE.INTRA") for row in rows] |
| intra_values = [value for value in intra_values if value is not None] |
| score_mean = _mean(score_values) |
| score_sd = _stdev(score_values, score_mean) |
| intra_mean = _mean(intra_values) |
| intra_sd = _stdev(intra_values, intra_mean) |
| enriched: list[dict[str, Any]] = [] |
| for row in rows: |
| item = dict(row) |
| score = _score_from_row(item, "final_score", "SCORE") |
| intra = _score_from_row(item, "SCORE.INTRA") |
| inter = _score_from_row(item, "SCORE.INTER") |
| restr = _score_from_row(item, "SCORE.RESTR") |
| intra_fraction = None |
| if score is not None and abs(score) > 1e-9 and intra is not None: |
| intra_fraction = abs(intra) / abs(score) |
| elif intra is not None and abs(intra) > 0.0: |
| intra_fraction = math.inf |
| intra_z = ((intra - intra_mean) / intra_sd) if intra is not None and intra_sd else 0.0 |
| score_z = ((score - score_mean) / score_sd) if score is not None and score_sd else 0.0 |
| dominant_intra_soft = bool(intra_fraction is not None and math.isfinite(intra_fraction) and intra_fraction >= max_intra_fraction_soft) |
| dominant_intra_hard = bool(intra_fraction is not None and math.isfinite(intra_fraction) and intra_fraction >= max_intra_fraction_hard) |
| intra_outlier = _boolish(item.get("intra_outlier")) or bool(intra is not None and intra_z <= -abs(intra_z_threshold)) or dominant_intra_soft |
| score_outlier = _boolish(item.get("score_outlier")) or bool(score is not None and score_z <= -abs(score_z_threshold)) |
| warnings = [token for token in str(item.get("component_warning", "")).split(",") if token.strip()] |
| if intra_outlier and "intra_outlier" not in warnings: |
| warnings.append("intra_outlier") |
| if score_outlier and "score_outlier" not in warnings: |
| warnings.append("score_outlier") |
| if dominant_intra_soft and "intra_dominance" not in warnings: |
| warnings.append("intra_dominance") |
| severe_combined = (score_outlier and intra_outlier) or dominant_intra_hard |
| item["SCORE"] = score if score is not None else item.get("SCORE", "") |
| item["SCORE.INTER"] = inter if inter is not None else item.get("SCORE.INTER", "") |
| item["SCORE.INTRA"] = intra if intra is not None else item.get("SCORE.INTRA", "") |
| item["SCORE.RESTR"] = restr if restr is not None else item.get("SCORE.RESTR", "") |
| item["intra_fraction"] = intra_fraction if intra_fraction is not None and math.isfinite(intra_fraction) else ("" if intra_fraction is None else "inf") |
| item["intra_dominance"] = dominant_intra_soft |
| item["intra_outlier"] = intra_outlier |
| item["score_outlier"] = score_outlier |
| item["component_warning"] = ",".join(warnings) |
| penalty = 0.0 |
| if intra_outlier: |
| penalty += 2.0 |
| if score_outlier: |
| penalty += 2.0 |
| if dominant_intra_soft: |
| penalty += 3.0 |
| if severe_combined: |
| penalty += 8.0 |
| item["adjusted_score"] = (score + penalty) if score is not None else "" |
| filtered_reasons: list[str] = [] |
| if severe_combined and intra_outlier: |
| filtered_reasons.append("intra_outlier") |
| if severe_combined and score_outlier: |
| filtered_reasons.append("score_outlier") |
| if dominant_intra_hard: |
| filtered_reasons.append("intra_dominance") |
| item["filtered_out"] = bool(filtered_reasons) |
| item["filtered_reason"] = ",".join(filtered_reasons) |
| item["downranked"] = bool(warnings) and not item["filtered_out"] |
| item["potential_strain_artifact"] = intra_outlier or dominant_intra_soft |
| enriched.append(item) |
| return enriched |
|
|
|
|
| def _attach_vs_full( |
| rows: list[dict[str, Any]], |
| full_rows: list[dict[str, Any]], |
| universe_complete: bool, |
| ) -> list[dict[str, Any]]: |
| full_map = { |
| str(row["ligand_id"]): { |
| "rank_vs_full": int(row["rank_vs_full"]), |
| "percentile_vs_full": float(row["percentile_vs_full"]), |
| "full_score": _score_from_row(row, "SCORE"), |
| } |
| for row in full_rows |
| } |
| enriched: list[dict[str, Any]] = [] |
| for row in rows: |
| item = dict(row) |
| ligand_id = str(item.get("ligand_id", "")) |
| entry = full_map.get(ligand_id) |
| if entry and universe_complete: |
| item["rank_vs_full"] = entry["rank_vs_full"] |
| item["percentile_vs_full"] = entry["percentile_vs_full"] |
| item["not_comparable"] = False |
| item["not_comparable_reason"] = "" |
| else: |
| item["rank_vs_full"] = "" |
| item["percentile_vs_full"] = "" |
| item["not_comparable"] = True |
| item["not_comparable_reason"] = "ligand_missing_in_full" if entry is None else "full_universe_incomplete" |
| enriched.append(item) |
| return enriched |
|
|
|
|
| def _best_row(rows: list[dict[str, Any]], *score_keys: str) -> dict[str, Any] | None: |
| ranked = [row for row in rows if _score_from_row(row, *score_keys) is not None] |
| if not ranked: |
| return None |
| return _sort_by_score(ranked, *score_keys)[0] |
|
|
|
|
| def _overlap_count(full_rows: list[dict[str, Any]], sample_rows: list[dict[str, Any]], n: int, *score_keys: str) -> int: |
| full_top = {str(row["ligand_id"]) for row in _sort_by_score(full_rows, "SCORE")[:n]} |
| sample_top = {str(row["ligand_id"]) for row in _sort_by_score(sample_rows, *score_keys)[:n]} |
| return len(full_top & sample_top) |
|
|
|
|
| def _trace_lookup(trace_rows: list[dict[str, Any]], final_level: int) -> dict[str, dict[str, Any]]: |
| by_id: dict[str, dict[str, Any]] = {} |
| for row in trace_rows: |
| ligand_id = str(row.get("ligand_id", "")) |
| prev = by_id.get(ligand_id) |
| level = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0) |
| prev_level = int(_float(prev.get("selected_fidelity_runs"), 0.0) or 0) if prev else -1 |
| if prev is None or level > prev_level or (level == final_level and prev_level != final_level): |
| by_id[ligand_id] = dict(row) |
| return by_id |
|
|
|
|
| def _estimate_total_runs(rows: list[dict[str, Any]], fallback_runs: int) -> int: |
| values = [] |
| for row in rows: |
| value = _float(row.get("n_rdock_runs_total_spent")) |
| if value is not None: |
| values.append(int(value)) |
| if values: |
| return sum(values) |
| return len(rows) * max(0, int(fallback_runs)) |
|
|
|
|
| def _load_reference_ids(run_dir: Path, reference_mode: str) -> list[str]: |
| if reference_mode != "sampled": |
| return [] |
| sample_path = run_dir / "tables" / "reference_sample_ligand_ids.txt" |
| if not sample_path.exists(): |
| return [] |
| return [line.strip() for line in sample_path.read_text(encoding="utf-8").splitlines() if line.strip()] |
|
|
|
|
| def _time_breakdown(run_dir: Path, existing_metrics: dict[str, Any], final_level: int) -> dict[str, Any]: |
| checkpoints = run_dir / "checkpoints" |
| full_ckpt = _load_json_if_exists(checkpoints / "full_docking.json") |
| single_ckpt = _load_json_if_exists(checkpoints / "single_fidelity.json") |
| random_ckpt = _load_json_if_exists(checkpoints / "random_baseline.json") |
| walltime = _float(existing_metrics.get("walltime_total_seconds"), 0.0) or 0.0 |
| docking_total = _float(existing_metrics.get("docking_time_seconds"), 0.0) or 0.0 |
| full_docking = _float(full_ckpt.get("full_docking_seconds"), 0.0) or 0.0 |
| single_docking = _float(single_ckpt.get("seconds"), 0.0) or 0.0 |
| random_docking = _float(random_ckpt.get("seconds"), 0.0) or 0.0 |
| training = _float(existing_metrics.get("training_time_seconds"), 0.0) or 0.0 |
| parsing = _float(existing_metrics.get("parsing_time_seconds"), 0.0) or 0.0 |
| split_merge = _float(existing_metrics.get("sdf_split_merge_time_seconds"), 0.0) or 0.0 |
| scheduler = _float(existing_metrics.get("scheduler_time_seconds"), 0.0) or 0.0 |
| io_time = _float(existing_metrics.get("io_time_seconds"), 0.0) or 0.0 |
| known = docking_total + training + parsing + split_merge + scheduler + io_time |
| overhead = max(0.0, walltime - known) |
| overhead_fraction = (overhead / walltime) if walltime > 0 else 0.0 |
| warnings: list[str] = [] |
| if overhead_fraction > 0.30: |
| warnings.append("overhead_fraction_gt_30pct") |
| return { |
| "walltime_total_seconds": walltime, |
| "docking_time_seconds": docking_total, |
| "training_time_seconds": training, |
| "parsing_time_seconds": parsing, |
| "sdf_split_merge_time_seconds": split_merge, |
| "scheduler_time_seconds": scheduler, |
| "io_time_seconds": io_time, |
| "overhead_unclassified_seconds": overhead, |
| "overhead_fraction": overhead_fraction, |
| "time_warnings": warnings, |
| "final_fidelity_runs": final_level, |
| "full_docking_time_seconds": full_docking, |
| "single_fidelity_time_seconds": single_docking, |
| "random_baseline_time_seconds": random_docking, |
| "multifidelity_docking_time_seconds": max(0.0, docking_total - full_docking - single_docking - random_docking), |
| } |
|
|
|
|
| def _render_report( |
| run_dir: Path, |
| metrics: dict[str, Any], |
| comparability: dict[str, Any], |
| final_raw_rows: list[dict[str, Any]], |
| final_downranked_rows: list[dict[str, Any]], |
| final_filtered_rows: list[dict[str, Any]], |
| ) -> str: |
| lines = [ |
| f"# benchmark-adaptive audit: {metrics.get('target_id') or run_dir.name}", |
| "", |
| f"## {metrics.get('benchmark_status', 'BENCHMARK PARTIAL / NOT COMPARABLE')}", |
| "", |
| "## Comparability", |
| f"- comparable: `{comparability.get('comparable')}`", |
| f"- same_target_config: `{comparability.get('same_target_config')}`", |
| f"- same_dataset_manifest: `{comparability.get('same_dataset_manifest')}`", |
| f"- same_final_fidelity_runs: `{comparability.get('same_final_fidelity_runs')}`", |
| f"- stale_checkpoint_detected: `{comparability.get('stale_checkpoint_detected')}`", |
| ] |
| for reason in comparability.get("reasons", []): |
| lines.append(f"- reason: `{reason}`") |
| if not comparability.get("comparable"): |
| lines.extend(["", "> WARNING: this benchmark is not fully comparable; rank/percentile claims should be treated as non-authoritative."]) |
| lines.extend( |
| [ |
| "", |
| "## Corrected Metrics", |
| ] |
| ) |
| ordered_keys = [ |
| "best_raw_hit_ligand_id", |
| "best_raw_hit_score", |
| "best_filtered_hit_ligand_id", |
| "best_filtered_hit_score", |
| "best_random_hit_ligand_id", |
| "best_random_hit_score", |
| "best_random_filtered_hit_ligand_id", |
| "best_random_filtered_hit_score", |
| "best_single_fidelity_ligand_id", |
| "best_single_fidelity_score", |
| "best_full_docking_ligand_id", |
| "best_full_docking_score", |
| "multifidelity_rank_vs_full", |
| "multifidelity_percentile_vs_full", |
| "random_rank_vs_full", |
| "random_percentile_vs_full", |
| "single_fidelity_rank_vs_full", |
| "single_fidelity_percentile_vs_full", |
| "adaptive_gain_score", |
| "adaptive_gain_score_filtered", |
| "multifidelity_total_runs_spent", |
| "random_total_runs_spent", |
| "single_fidelity_total_runs_spent", |
| "cost_ratio", |
| "walltime_total_seconds", |
| "docking_time_seconds", |
| "training_time_seconds", |
| "parsing_time_seconds", |
| "sdf_split_merge_time_seconds", |
| "scheduler_time_seconds", |
| "io_time_seconds", |
| "overhead_unclassified_seconds", |
| "overhead_fraction", |
| "filtered_outlier_count", |
| ] |
| for key in ordered_keys: |
| if key in metrics: |
| lines.append(f"- {key}: `{metrics.get(key)}`") |
| for warning in metrics.get("warnings", []): |
| lines.append(f"- warning: `{warning}`") |
| lines.extend(["", "## Top Raw Final Hits"]) |
| for row in final_raw_rows[:20]: |
| lines.append( |
| f"- `{row.get('ligand_id')}` SCORE `{row.get('final_score', row.get('SCORE', ''))}` " |
| f"SCORE.INTER `{row.get('SCORE.INTER', '')}` SCORE.INTRA `{row.get('SCORE.INTRA', '')}` " |
| f"SCORE.RESTR `{row.get('SCORE.RESTR', '')}` intra_fraction `{row.get('intra_fraction', '')}` " |
| f"raw_rank `{row.get('raw_rank', '')}` downranked_rank `{row.get('downranked_rank', '')}` filtered_rank `{row.get('filtered_rank', '')}` " |
| f"rank_vs_full `{row.get('rank_vs_full', '')}` percentile_vs_full `{row.get('percentile_vs_full', '')}` " |
| f"warnings `{row.get('component_warning', '')}`" |
| ) |
| lines.extend(["", "## Top Downranked Final Hits"]) |
| for row in final_downranked_rows[:20]: |
| lines.append( |
| f"- `{row.get('ligand_id')}` SCORE `{row.get('final_score', row.get('SCORE', ''))}` " |
| f"adjusted `{row.get('adjusted_score', '')}` SCORE.INTER `{row.get('SCORE.INTER', '')}` SCORE.INTRA `{row.get('SCORE.INTRA', '')}` " |
| f"intra_fraction `{row.get('intra_fraction', '')}` raw_rank `{row.get('raw_rank', '')}` downranked_rank `{row.get('downranked_rank', '')}` " |
| f"warnings `{row.get('component_warning', '')}`" |
| ) |
| lines.extend(["", "## Top Filtered Final Hits"]) |
| for row in final_filtered_rows[:20]: |
| lines.append( |
| f"- `{row.get('ligand_id')}` SCORE `{row.get('final_score', row.get('SCORE', ''))}` " |
| f"SCORE.INTER `{row.get('SCORE.INTER', '')}` SCORE.INTRA `{row.get('SCORE.INTRA', '')}` " |
| f"SCORE.RESTR `{row.get('SCORE.RESTR', '')}` intra_fraction `{row.get('intra_fraction', '')}` " |
| f"raw_rank `{row.get('raw_rank', '')}` downranked_rank `{row.get('downranked_rank', '')}` filtered_rank `{row.get('filtered_rank', '')}` " |
| f"rank_vs_full `{row.get('rank_vs_full', '')}` percentile_vs_full `{row.get('percentile_vs_full', '')}` " |
| f"warnings `{row.get('component_warning', '')}`" |
| ) |
| return "\n".join(lines) + "\n" |
|
|
|
|
| def audit_benchmark_run(run_dir: str | Path) -> dict[str, Any]: |
| root = Path(run_dir) |
| tables = root / "tables" |
| metrics_dir = root / "metrics" |
| raw_metrics = _load_json_if_exists(metrics_dir / "adaptive_benchmark_metrics_raw.json") |
| existing_metrics = raw_metrics or _load_json_if_exists(metrics_dir / "adaptive_benchmark_metrics.json") |
| validation_metrics = _load_json_if_exists(metrics_dir / "validation_metrics.json") |
| signature = _load_json_if_exists(root / "checkpoints" / "run_signature.json") |
| config = _load_struct_if_exists(root / "config.yaml") |
| manifest = _load_json_if_exists(root / "manifest.json") |
| dataset_dir_value = config.get("dataset_dir") or existing_metrics.get("dataset_dir") or manifest.get("dataset_dir") |
| dataset_dir = Path(dataset_dir_value) if dataset_dir_value else None |
| dataset_repair: dict[str, Any] = {} |
| dataset_manifest: dict[str, Any] = {} |
| if dataset_dir and dataset_dir.exists(): |
| dataset_repair = repair_dataset_dir(dataset_dir) |
| dataset_manifest = _load_json_if_exists(dataset_dir / "dataset_manifest.json") |
| reference_mode = str( |
| config.get("reference_mode") |
| or signature.get("reference_mode") |
| or raw_metrics.get("reference_mode") |
| or validation_metrics.get("reference_mode") |
| or existing_metrics.get("reference_mode") |
| or "full" |
| ).lower() |
| evaluation_pool_mode = str( |
| config.get("evaluation_pool_mode") |
| or signature.get("evaluation_pool_mode") |
| or raw_metrics.get("evaluation_pool_mode") |
| or validation_metrics.get("evaluation_pool_mode") |
| or existing_metrics.get("evaluation_pool_mode") |
| or "same_pool" |
| ).lower() |
| final_level = 0 |
| levels = config.get("fidelity_levels") or signature.get("fidelity_levels") or raw_metrics.get("fidelity_levels") or validation_metrics.get("fidelity_levels") or existing_metrics.get("fidelity_levels") or [] |
| if isinstance(levels, list) and levels: |
| final_level = int(levels[-1]) |
| elif isinstance(levels, str) and levels.strip(): |
| final_level = int(str(levels).split(",")[-1].strip()) |
|
|
| full_table_rows = _read_rows(tables / "full_docking_scores.csv") if (tables / "full_docking_scores.csv").exists() else [] |
| full_rows = _augment_full_rows(full_table_rows) if full_table_rows else [] |
| full_rank_map = {str(row["ligand_id"]): row for row in full_rows} |
| normalized_full_rows: list[dict[str, Any]] = [] |
| for row in full_table_rows: |
| item = dict(row) |
| item.update({k: v for k, v in full_rank_map.get(str(row.get("ligand_id", "")), {}).items() if k not in item or item[k] in {"", None}}) |
| normalized_full_rows.append(item) |
| if normalized_full_rows: |
| write_rows_csv(normalized_full_rows, tables / "full_docking_scores.csv") |
| full_ligand_ids = {str(row["ligand_id"]) for row in normalized_full_rows} |
| expected_universe = int(_float(dataset_manifest.get("ligands_prepared"), len(full_rows)) or len(full_rows)) |
| reference_ids = _load_reference_ids(root, reference_mode) |
| reference_sample_size = int( |
| _float( |
| config.get("reference_sample_size") |
| or signature.get("reference_sample_size") |
| or raw_metrics.get("reference_sample_size") |
| or validation_metrics.get("reference_sample_size"), |
| len(normalized_full_rows) if reference_mode == "sampled" else expected_universe, |
| ) |
| or (len(normalized_full_rows) if reference_mode == "sampled" else expected_universe) |
| ) |
| n_reference_ligands = expected_universe if reference_mode == "full" else (len(reference_ids) if reference_ids else reference_sample_size if reference_mode == "sampled" else 0) |
| reference_completion_fraction = len(normalized_full_rows) / max(1, n_reference_ligands) if n_reference_ligands else 0.0 |
| full_universe_complete = reference_mode == "full" and reference_completion_fraction >= 0.99 |
|
|
| audit_settings = { |
| "score_z_threshold": float(config.get("score_z_threshold") or signature.get("command_args", {}).get("score_z_threshold") or validation_metrics.get("score_z_threshold") or 5.0), |
| "intra_z_threshold": float(config.get("intra_z_threshold") or signature.get("command_args", {}).get("intra_z_threshold") or validation_metrics.get("intra_z_threshold") or 4.0), |
| "max_intra_fraction_soft": float(config.get("max_intra_fraction_soft") or signature.get("command_args", {}).get("max_intra_fraction_soft") or validation_metrics.get("max_intra_fraction_soft") or config.get("max_intra_fraction") or 0.75), |
| "max_intra_fraction_hard": float(config.get("max_intra_fraction_hard") or signature.get("command_args", {}).get("max_intra_fraction_hard") or validation_metrics.get("max_intra_fraction_hard") or 0.9), |
| } |
|
|
| random_rows = _apply_component_flags( |
| _attach_vs_full(_read_rows(tables / "random_baseline_scores.csv"), full_rows, full_universe_complete), |
| **audit_settings, |
| ) |
| single_path = tables / "single_fidelity_adaptive_scores.csv" |
| if not single_path.exists(): |
| single_path = tables / "single_fidelity_scores.csv" |
| single_rows = _apply_component_flags(_attach_vs_full(_read_rows(single_path), full_rows, full_universe_complete), **audit_settings) |
| trace_rows = _read_rows(tables / "multifidelity_trace.csv") if (tables / "multifidelity_trace.csv").exists() else [] |
| final_seed_rows = _read_rows(tables / "final_hits.csv") |
| trace_map = _trace_lookup(trace_rows, final_level) |
| final_raw_rows: list[dict[str, Any]] = [] |
| for row in final_seed_rows: |
| ligand_id = str(row.get("ligand_id", "")) |
| merged = dict(row) |
| merged.update({key: value for key, value in trace_map.get(ligand_id, {}).items() if key not in {"ligand_id"}}) |
| if "final_score" not in merged or str(merged.get("final_score", "")).strip() == "": |
| if str(merged.get("is_final_fidelity", "")).lower() in {"true", "1"}: |
| merged["final_score"] = merged.get("SCORE", merged.get("current_best_score", "")) |
| final_raw_rows.append(merged) |
| final_raw_rows = _apply_component_flags(_attach_vs_full(final_raw_rows, full_rows, full_universe_complete), **audit_settings) |
| final_raw_rows = _sort_by_score(final_raw_rows, "final_score", "SCORE") |
| for idx, row in enumerate(final_raw_rows, start=1): |
| row["raw_rank"] = idx |
| write_rows_csv(final_raw_rows, tables / "final_hits_raw.csv") |
| final_downranked_rows = _sort_by_score([dict(row) for row in final_raw_rows], "adjusted_score", "final_score", "SCORE") |
| for idx, row in enumerate(final_downranked_rows, start=1): |
| row["downranked_rank"] = idx |
| downrank_map = {str(row["ligand_id"]): row["downranked_rank"] for row in final_downranked_rows} |
| write_rows_csv(final_downranked_rows, tables / "final_hits_downranked.csv") |
| final_filtered_rows = [dict(row) for row in final_downranked_rows if not _boolish(row.get("filtered_out"))] |
| final_filtered_rows = _sort_by_score(final_filtered_rows, "final_score", "SCORE") |
| for idx, row in enumerate(final_filtered_rows, start=1): |
| row["filtered_rank"] = idx |
| filtered_map = {str(row["ligand_id"]): row["filtered_rank"] for row in final_filtered_rows} |
| for row in final_raw_rows: |
| row["downranked_rank"] = downrank_map.get(str(row.get("ligand_id", "")), "") |
| row["filtered_rank"] = filtered_map.get(str(row.get("ligand_id", "")), "") |
| for row in final_downranked_rows: |
| row["raw_rank"] = next((raw["raw_rank"] for raw in final_raw_rows if str(raw.get("ligand_id")) == str(row.get("ligand_id"))), "") |
| row["filtered_rank"] = filtered_map.get(str(row.get("ligand_id", "")), "") |
| write_rows_csv(final_filtered_rows, tables / "final_hits_filtered.csv") |
|
|
| random_filtered_rows = [dict(row) for row in random_rows if not _boolish(row.get("filtered_out"))] |
| single_filtered_rows = [dict(row) for row in single_rows if not _boolish(row.get("filtered_out"))] |
|
|
| best_full = _best_row(full_rows, "SCORE") |
| best_raw = _best_row(final_raw_rows, "final_score", "SCORE") |
| best_filtered = _best_row(final_filtered_rows, "final_score", "SCORE") |
| best_random = _best_row(random_rows, "final_score", "SCORE") |
| best_random_filtered = _best_row(random_filtered_rows, "final_score", "SCORE") |
| best_single = _best_row(single_rows, "final_score", "SCORE") |
|
|
| reference_id_set = set(reference_ids) if reference_ids else full_ligand_ids |
| overlap_multifidelity_full = len({str(row["ligand_id"]) for row in final_raw_rows} & reference_id_set) |
| overlap_random_full = len({str(row["ligand_id"]) for row in random_rows} & reference_id_set) |
| overlap_single_full = len({str(row["ligand_id"]) for row in single_rows} & reference_id_set) |
| same_target_config, target_reasons = _same_target_config(root, dataset_dir) |
| same_dataset_manifest = bool(dataset_dir and dataset_dir.exists() and dataset_manifest) |
| same_final_fidelity_runs = True |
| final_reasons: list[str] = [] |
| full_run_metrics = _load_json_if_exists(root / "full_docking" / "metrics" / "rdock_metrics.json") |
| random_run_metrics = _load_json_if_exists(root / "random_baseline" / "metrics" / "rdock_metrics.json") |
| single_run_metrics = _load_json_if_exists(root / "single_fidelity_adaptive" / "metrics" / "rdock_metrics.json") |
| for label, payload in (("full_docking", full_run_metrics), ("random_baseline", random_run_metrics), ("single_fidelity", single_run_metrics)): |
| if payload: |
| n_runs = int(_float(payload.get("n_runs"), final_level) or final_level) |
| if final_level and n_runs != final_level: |
| same_final_fidelity_runs = False |
| final_reasons.append(f"{label}_n_runs={n_runs} differs from final_fidelity={final_level}") |
| stale_checkpoint_detected = (root / "checkpoints" / "failure.json").exists() |
| reasons: list[str] = [] |
| reasons.extend(target_reasons) |
| reasons.extend(final_reasons) |
| if reference_mode == "full" and not full_universe_complete: |
| reasons.append(f"incomplete_full_reference coverage={reference_completion_fraction:.4f}") |
| expected_overlap_size = len(reference_id_set) if reference_mode == "sampled" and evaluation_pool_mode == "same_pool" else None |
| for label, rows, overlap in ( |
| ("multifidelity", final_raw_rows, overlap_multifidelity_full), |
| ("random", random_rows, overlap_random_full), |
| ("single_fidelity", single_rows, overlap_single_full), |
| ): |
| if overlap != len(rows): |
| reasons.append(f"{label}_contains_ligands_missing_from_full") |
| if expected_overlap_size is not None and any(str(row.get("ligand_id", "")) not in reference_id_set for row in rows): |
| reasons.append(f"{label}_contains_ligands_missing_from_reference_sample") |
| if best_raw and str(best_raw.get("ligand_id")) not in full_ligand_ids: |
| reasons.append("best_multifidelity_ligand_missing_from_full") |
| if best_random and str(best_random.get("ligand_id")) not in full_ligand_ids: |
| reasons.append("best_random_ligand_missing_from_full") |
| if best_single and str(best_single.get("ligand_id")) not in full_ligand_ids: |
| reasons.append("best_single_fidelity_ligand_missing_from_full") |
| if best_single and best_full and same_target_config and same_dataset_manifest and same_final_fidelity_runs and overlap_single_full == len(single_rows): |
| if _score_from_row(best_single, "final_score", "SCORE") is not None and _score_from_row(best_full, "SCORE") is not None: |
| epsilon = float(config.get("single_full_score_epsilon") or signature.get("command_args", {}).get("single_full_score_epsilon") or 1.0) |
| if _score_from_row(best_single, "final_score", "SCORE") < (_score_from_row(best_full, "SCORE") - epsilon): |
| reasons.append("hard_warning_single_fidelity_better_than_full_docking_in_same_universe") |
| if stale_checkpoint_detected: |
| reasons.append("stale_checkpoint_detected") |
| time_metrics = _time_breakdown(root, existing_metrics, final_level) |
| multifidelity_total_runs = int( |
| _float(validation_metrics.get("multifidelity_total_runs_spent"), None) |
| or _float(validation_metrics.get("total_rdock_runs_spent"), None) |
| or _float(raw_metrics.get("multifidelity_total_runs_spent"), None) |
| or _float(raw_metrics.get("total_rdock_runs_spent"), None) |
| or _float(existing_metrics.get("multifidelity_total_runs_spent"), None) |
| or _float(existing_metrics.get("total_rdock_runs_spent"), None) |
| or _estimate_total_runs(trace_rows, 0) |
| or _estimate_total_runs(final_raw_rows, final_level) |
| ) |
| random_total_runs = _estimate_total_runs(random_rows, final_level) |
| single_total_runs = _estimate_total_runs(single_rows, final_level) |
| cost_ratio = (random_total_runs / multifidelity_total_runs) if multifidelity_total_runs else None |
| cost_ratio_single = (single_total_runs / multifidelity_total_runs) if multifidelity_total_runs else None |
| warnings = list(time_metrics.get("time_warnings", [])) |
| if cost_ratio is not None and abs(cost_ratio - 1.0) > 0.05: |
| warnings.append("cost_ratio_differs_by_more_than_5pct") |
| reasons.append("not_cost_comparable_random") |
| if cost_ratio_single is not None and abs(cost_ratio_single - 1.0) > 0.05: |
| warnings.append("single_cost_ratio_differs_by_more_than_5pct") |
| reasons.append("not_cost_comparable_single") |
| if reference_mode == "none": |
| reasons.append("reference_mode_none") |
| comparable = False if reference_mode == "none" else not reasons |
|
|
| best_raw_score = _score_from_row(best_raw or {}, "final_score", "SCORE") |
| best_filtered_score = _score_from_row(best_filtered or {}, "final_score", "SCORE") |
| best_random_score = _score_from_row(best_random or {}, "final_score", "SCORE") |
| best_random_filtered_score = _score_from_row(best_random_filtered or {}, "final_score", "SCORE") |
| best_single_score = _score_from_row(best_single or {}, "final_score", "SCORE") |
| best_full_score = _score_from_row(best_full or {}, "SCORE") |
|
|
| corrected_metrics: dict[str, Any] = { |
| "strategy": config.get("strategy") or existing_metrics.get("strategy"), |
| "dataset_dir": str(dataset_dir) if dataset_dir else "", |
| "target_id": (dataset_manifest.get("pdb_id") or existing_metrics.get("target_id") or root.name), |
| "reference_mode": reference_mode, |
| "evaluation_pool_mode": evaluation_pool_mode, |
| "benchmark_status": ( |
| "BENCHMARK COMPLETE" |
| if reference_mode == "full" and comparable |
| else "BENCHMARK SAMPLED REFERENCE" |
| if reference_mode == "sampled" and not reasons |
| else "BENCHMARK PARTIAL / NOT COMPARABLE" |
| ), |
| "best_final_SCORE_found_by_multifidelity": best_raw_score, |
| "best_filtered_SCORE_found_by_multifidelity": best_filtered_score, |
| "best_final_SCORE_found_by_random_at_same_cost": best_random_score, |
| "best_filtered_SCORE_found_by_random_at_same_cost": best_random_filtered_score, |
| "best_final_SCORE_found_by_single_fidelity": best_single_score, |
| "best_SCORE_in_full_docking": best_full_score, |
| "best_raw_hit_ligand_id": best_raw.get("ligand_id") if best_raw else None, |
| "best_raw_hit_score": best_raw_score, |
| "best_filtered_hit_ligand_id": best_filtered.get("ligand_id") if best_filtered else None, |
| "best_filtered_hit_score": best_filtered_score, |
| "best_random_hit_ligand_id": best_random.get("ligand_id") if best_random else None, |
| "best_random_hit_score": best_random_score, |
| "best_random_filtered_hit_ligand_id": best_random_filtered.get("ligand_id") if best_random_filtered else None, |
| "best_random_filtered_hit_score": best_random_filtered_score, |
| "best_single_fidelity_ligand_id": best_single.get("ligand_id") if best_single else None, |
| "best_single_fidelity_score": best_single_score, |
| "best_full_docking_ligand_id": best_full.get("ligand_id") if best_full else None, |
| "best_full_docking_score": best_full_score, |
| "multifidelity_rank_vs_full": best_raw.get("rank_vs_full") if best_raw and not _boolish(best_raw.get("not_comparable")) else None, |
| "multifidelity_percentile_vs_full": best_raw.get("percentile_vs_full") if best_raw and not _boolish(best_raw.get("not_comparable")) else None, |
| "random_rank_vs_full": best_random.get("rank_vs_full") if best_random and not _boolish(best_random.get("not_comparable")) else None, |
| "random_percentile_vs_full": best_random.get("percentile_vs_full") if best_random and not _boolish(best_random.get("not_comparable")) else None, |
| "single_fidelity_rank_vs_full": best_single.get("rank_vs_full") if best_single and not _boolish(best_single.get("not_comparable")) else None, |
| "single_fidelity_percentile_vs_full": best_single.get("percentile_vs_full") if best_single and not _boolish(best_single.get("not_comparable")) else None, |
| "adaptive_gain_score": (best_random_score - best_raw_score) if best_random_score is not None and best_raw_score is not None else None, |
| "adaptive_gain_score_filtered": (best_random_filtered_score - best_filtered_score) if best_random_filtered_score is not None and best_filtered_score is not None else None, |
| "adaptive_gain_over_random": (best_random_score - best_raw_score) if best_random_score is not None and best_raw_score is not None else None, |
| "multifidelity_total_runs_spent": multifidelity_total_runs, |
| "random_total_runs_spent": random_total_runs, |
| "single_fidelity_total_runs_spent": single_total_runs, |
| "cost_ratio": cost_ratio, |
| "cost_ratio_single": cost_ratio_single, |
| "reference_completion_fraction": reference_completion_fraction, |
| "filtered_outlier_count": sum(1 for row in final_raw_rows if _boolish(row.get("filtered_out"))), |
| "raw_final_hits_count": len(final_raw_rows), |
| "downranked_final_hits_count": len(final_downranked_rows), |
| "filtered_final_hits_count": len(final_filtered_rows), |
| "outlier_policy": config.get("outlier_policy") or signature.get("command_args", {}).get("outlier_policy") or "downrank", |
| "warnings": warnings, |
| "dataset_repair_warnings": dataset_repair.get("warnings", []), |
| } |
| corrected_metrics.update(time_metrics) |
|
|
| comparability = { |
| "dataset_ligands_prepared": expected_universe, |
| "n_reference_ligands": n_reference_ligands, |
| "n_full_ligands": len(normalized_full_rows), |
| "n_multifidelity_ligands": len(final_raw_rows), |
| "n_random_ligands": len(random_rows), |
| "n_single_fidelity_ligands": len(single_rows), |
| "overlap_multifidelity_reference": overlap_multifidelity_full, |
| "overlap_random_reference": overlap_random_full, |
| "overlap_single_reference": overlap_single_full, |
| "cost_ratio_random_vs_multifidelity": cost_ratio, |
| "cost_ratio_single_vs_multifidelity": cost_ratio_single, |
| "same_target_config": same_target_config, |
| "same_dataset_manifest": same_dataset_manifest, |
| "same_final_fidelity_runs": same_final_fidelity_runs, |
| "stale_checkpoint_detected": stale_checkpoint_detected, |
| "comparable": comparable, |
| "reasons": reasons, |
| } |
|
|
| if existing_metrics: |
| dump_json_like(metrics_dir / "adaptive_benchmark_metrics_raw.json", existing_metrics) |
| dump_json_like(metrics_dir / "adaptive_benchmark_metrics.json", corrected_metrics) |
| dump_json_like(metrics_dir / "adaptive_benchmark_metrics_corrected.json", corrected_metrics) |
| dump_json_like(metrics_dir / "comparability_audit.json", comparability) |
| (root / "report.md").write_text(_render_report(root, corrected_metrics, comparability, final_raw_rows, final_downranked_rows, final_filtered_rows), encoding="utf-8") |
| return { |
| "run_dir": str(root), |
| "metrics": corrected_metrics, |
| "comparability_audit": comparability, |
| "final_hits_raw": str(tables / "final_hits_raw.csv"), |
| "final_hits_downranked": str(tables / "final_hits_downranked.csv"), |
| "final_hits_filtered": str(tables / "final_hits_filtered.csv"), |
| "report": str(root / "report.md"), |
| } |
|
|
|
|
| def build_arg_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description="Re-audit an existing adaptive benchmark run without re-running docking.") |
| parser.add_argument("--run-dir", required=True) |
| return parser |
|
|
|
|
| def run_from_args(args: argparse.Namespace) -> dict[str, Any]: |
| return audit_benchmark_run(args.run_dir) |
|
|
|
|
| def main() -> int: |
| parser = build_arg_parser() |
| args = parser.parse_args() |
| try: |
| print(json.dumps(run_from_args(args), indent=2)) |
| except Exception as exc: |
| failure = { |
| "error": str(exc), |
| "traceback": traceback.format_exc(), |
| "run_dir": str(args.run_dir), |
| } |
| target = Path(args.run_dir) / "checkpoints" / "audit_failure.json" |
| dump_json_like(target, failure) |
| raise |
| return 0 |
|
|
