from __future__ import annotations import argparse import json import shutil from argparse import Namespace from pathlib import Path from typing import Any from .benchmark_adaptive import _load_input_block_map, _sample_reference_rows, _stable_json_hash, _write_json, _write_selected_sdf from .benchmark_triage_strategies import benchmark_triage_strategies from .dataset import read_ligand_metadata, validate_dataset_dir from .provenance import RDockPipelineError, require_file from .sdf import write_rows_csv def _read_json(path: Path) -> dict[str, Any]: return json.loads(path.read_text(encoding="utf-8")) def filter_ligand_ids_to_prepared_sdf( ligand_ids: list[str], prepared_ids: set[str], ) -> tuple[list[str], list[str]]: filtered: list[str] = [] missing: list[str] = [] for ligand_id in ligand_ids: if ligand_id in prepared_ids: filtered.append(ligand_id) else: missing.append(ligand_id) return filtered, missing def _filter_rows_to_prepared_sdf( rows: list[dict[str, Any]], prepared_ids: set[str], ) -> tuple[list[dict[str, Any]], list[str]]: ordered_ids = [str(row.get("ligand_id", "")) for row in rows] filtered_ids, missing_ids = filter_ligand_ids_to_prepared_sdf(ordered_ids, prepared_ids) filtered_id_set = set(filtered_ids) filtered_rows = [row for row in rows if str(row.get("ligand_id", "")) in filtered_id_set] return filtered_rows, missing_ids def _subset_dataset( dataset_dir: Path, out_dir: Path, evaluation_universe_size: int, evaluation_universe_seed: int, ) -> tuple[Path, list[dict[str, Any]], dict[str, Any]]: metadata_rows = read_ligand_metadata(dataset_dir / "ligands" / "ligand_metadata.csv") block_map = _load_input_block_map(require_file(dataset_dir / "ligands" / "all_ligands.sdf", "prepared ligands sdf")) prepared_ids = set(block_map) filtered_metadata_rows, missing_prepared_ids = _filter_rows_to_prepared_sdf(metadata_rows, prepared_ids) if evaluation_universe_size <= 0: raise RDockPipelineError("evaluation_universe_size must be > 0") if missing_prepared_ids: print( "WARNING: " f"Dropping {len(missing_prepared_ids)} ligand IDs absent from prepared SDF before evaluation universe sampling. " f"Examples: {missing_prepared_ids[:10]}" ) effective_universe_target = min(evaluation_universe_size, len(filtered_metadata_rows)) sampled_rows = _sample_reference_rows( filtered_metadata_rows, effective_universe_target, evaluation_universe_seed, 1, 50, ) if not sampled_rows: raise RDockPipelineError("Evaluation universe sampling produced no ligands") subset_dir = out_dir / "evaluation_dataset" if subset_dir.exists(): shutil.rmtree(subset_dir) (subset_dir / "ligands").mkdir(parents=True, exist_ok=True) (subset_dir / "target").mkdir(parents=True, exist_ok=True) (subset_dir / "qc").mkdir(parents=True, exist_ok=True) (subset_dir / "logs").mkdir(parents=True, exist_ok=True) shutil.copytree(dataset_dir / "target" / "rdock_prm", subset_dir / "target" / "rdock_prm", dirs_exist_ok=True) for name in ("target.mol2", "reference_ligand.sdf"): src = dataset_dir / "target" / name if src.exists(): shutil.copy2(src, subset_dir / "target" / name) for name in ("invalid_ligands.csv", "all_ligands.smi", "ligand_preparation_progress.json"): src = dataset_dir / "ligands" / name if src.exists(): shutil.copy2(src, subset_dir / "ligands" / name) prep_report = dataset_dir / "qc" / "preparation_report.md" if prep_report.exists(): shutil.copy2(prep_report, subset_dir / "qc" / "preparation_report.md") for name in ("pubchem_diagnostics.json", "pubchem_progress.json", "pubchem_progress.log", "commands.log"): src = dataset_dir / "logs" / name if src.exists(): shutil.copy2(src, subset_dir / "logs" / name) raw_dir = dataset_dir / "raw" if raw_dir.exists(): shutil.copytree(raw_dir, subset_dir / "raw", dirs_exist_ok=True) selected_ids = [str(row["ligand_id"]) for row in sampled_rows] _write_selected_sdf(block_map, selected_ids, subset_dir / "ligands" / "all_ligands.sdf") write_rows_csv(sampled_rows, subset_dir / "ligands" / "ligand_metadata.csv") manifest = _read_json(dataset_dir / "dataset_manifest.json") manifest["evaluation_universe_size"] = len(sampled_rows) manifest["requested_evaluation_universe_size"] = int(evaluation_universe_size) manifest["effective_evaluation_universe_size"] = len(sampled_rows) manifest["source_dataset_dir"] = str(dataset_dir) manifest["ligands_prepared"] = len(sampled_rows) manifest["n_prepared_ligands"] = len(sampled_rows) manifest["n_unique_parent_ligands"] = len(sampled_rows) manifest["evaluation_universe_seed"] = evaluation_universe_seed manifest["prepared_sdf_ligand_count"] = len(prepared_ids) manifest["metadata_ligand_count"] = len(metadata_rows) manifest["missing_prepared_ligands_count"] = len(missing_prepared_ids) manifest["missing_prepared_ligands_examples"] = missing_prepared_ids[:10] manifest["dropped_missing_prepared_ligands_count"] = len(missing_prepared_ids) _write_json(subset_dir / "dataset_manifest.json", manifest) diagnostics = { "requested_evaluation_universe_size": int(evaluation_universe_size), "effective_evaluation_universe_size": len(sampled_rows), "prepared_sdf_ligand_count": len(prepared_ids), "metadata_ligand_count": len(metadata_rows), "missing_prepared_ligands_count": len(missing_prepared_ids), "missing_prepared_ligands_examples": missing_prepared_ids[:10], "dropped_missing_prepared_ligands_count": len(missing_prepared_ids), } return subset_dir, sampled_rows, diagnostics def _cost_balance_status(summary: dict[str, Any], tolerance: float = 0.05) -> tuple[bool, list[str]]: by_strategy = dict(summary.get("by_strategy", {})) costs = { strategy: float(item["median_total_runs_spent"]) for strategy, item in by_strategy.items() if item.get("median_total_runs_spent") is not None } reasons: list[str] = [] if not costs: return False, ["missing_cost_metrics"] baseline = min(costs.values()) for strategy, value in costs.items(): if baseline <= 0: continue if abs(value - baseline) / baseline > tolerance: reasons.append(f"cost_imbalance:{strategy}") return len(reasons) == 0, reasons def benchmark_comparable_adaptive(args: argparse.Namespace) -> dict[str, Any]: dataset_dir = Path(args.dataset_dir) validate_dataset_dir(dataset_dir, check_rdock_tools=False) out_dir = Path(args.out) if getattr(args, "force", False) and out_dir.exists(): shutil.rmtree(out_dir) out_dir.mkdir(parents=True, exist_ok=True) subset_dir, sampled_rows, subset_diagnostics = _subset_dataset( dataset_dir, out_dir, int(args.evaluation_universe_size), int(args.evaluation_universe_seed), ) write_rows_csv(sampled_rows, out_dir / "tables" / "evaluation_universe.csv") strategy_args = Namespace( dataset_dir=str(subset_dir), reference_mode=str(args.reference_mode), reference_sample_size=int(getattr(args, "reference_sample_size", 0)), reference_sample_seed=int(getattr(args, "reference_sample_seed", args.evaluation_universe_seed)), strategies=str(args.strategies), triage_target_recall=float(getattr(args, "triage_target_recall", 0.95)), triage_retain_fraction=float(getattr(args, "triage_retain_fraction", 0.05)), calibration_size=int(getattr(args, "calibration_size", 1000)), fidelity_validation_size=int(getattr(args, "fidelity_validation_size", 100)), cost_budget_runs=int(args.cost_budget_runs), fidelity_levels=str(args.fidelity_levels), triage_model=str(getattr(args, "triage_model", "classifier")), classifier_top_percentile=float(getattr(args, "classifier_top_percentile", 0.05)), classifier_threshold_mode=str(getattr(args, "classifier_threshold_mode", "recall_target")), classifier_min_positives=int(getattr(args, "classifier_min_positives", 10)), classifier_holdout_fraction=float(getattr(args, "classifier_holdout_fraction", 0.25)), classifier_fallback=str(getattr(args, "classifier_fallback", "cluster_only")), model_fallback_if_worse=str(getattr(args, "model_fallback_if_worse", "none")), survivor_combination_policy=str(getattr(args, "survivor_combination_policy", "model_only")), adaptive_policy=str(getattr(args, "adaptive_policy", "cluster_bandit")), adaptive_policies="", regressor_contribution_mode=str(getattr(args, "regressor_contribution_mode", "gate")), classifier_weight=float(getattr(args, "classifier_weight", 1.0)), regressor_weight=float(getattr(args, "regressor_weight", 0.2)), cluster_quality_weight=float(getattr(args, "cluster_quality_weight", 0.4)), fixed_score_regressor_name=str(getattr(args, "fixed_score_regressor_name", "fixed_score_regressor_v1")), fixed_score_regressor_target=str(getattr(args, "fixed_score_regressor_target", "component_sane_affinity_like")), regressor_model_type=str(getattr(args, "regressor_model_type", "extra_trees")), promotion_policy=str(getattr(args, "promotion_policy", "quota_ladder")), exploration_fraction=float(getattr(args, "exploration_fraction", 0.35)), diversity_weight=float(getattr(args, "diversity_weight", 0.75)), uncertainty_weight=float(getattr(args, "uncertainty_weight", 0.2)), outlier_risk_weight=float(getattr(args, "outlier_risk_weight", 2.0)), min_per_cluster=int(getattr(args, "min_per_cluster", 1)), max_per_cluster=int(getattr(args, "max_per_cluster", 50)), triage_max_survivors=int(getattr(args, "triage_max_survivors", 0)), cluster_quota=int(getattr(args, "cluster_quota", 0)), promotion_temperature=float(getattr(args, "promotion_temperature", 1.0)), diagnostics_level=str(getattr(args, "diagnostics_level", "standard")), classifier_gate_fraction=float(getattr(args, "classifier_gate_fraction", 0.15)), classifier_max_gate_fraction=float(getattr(args, "classifier_max_gate_fraction", 0.2)), seeds=str(getattr(args, "seeds", "1,2,3")), jobs=str(args.jobs), chunk_size=int(args.chunk_size), rdock_timeout_seconds=int(args.rdock_timeout_seconds), cpu_fraction=float(args.cpu_fraction), out=str(out_dir / "strategy_runs"), force=bool(getattr(args, "force", False)), resume=bool(getattr(args, "resume", False)), model_validation_split=str(getattr(args, "model_validation_split", "cluster")), ) strategy_payload = benchmark_triage_strategies(strategy_args) summary = dict(strategy_payload.get("summary", {})) comparable, reasons = _cost_balance_status(summary) if str(args.reference_mode).lower() == "none": comparable = False reasons.append("reference_mode_none") manifest = { "dataset_dir": str(dataset_dir), "evaluation_universe_dataset_dir": str(subset_dir), "evaluation_universe_size": len(sampled_rows), "requested_evaluation_universe_size": subset_diagnostics["requested_evaluation_universe_size"], "effective_evaluation_universe_size": subset_diagnostics["effective_evaluation_universe_size"], "evaluation_universe_seed": int(args.evaluation_universe_seed), "evaluation_universe_hash": _stable_json_hash({"ligand_ids": [str(row["ligand_id"]) for row in sampled_rows]}), "prepared_sdf_ligand_count": subset_diagnostics["prepared_sdf_ligand_count"], "metadata_ligand_count": subset_diagnostics["metadata_ligand_count"], "missing_prepared_ligands_count": subset_diagnostics["missing_prepared_ligands_count"], "missing_prepared_ligands_examples": subset_diagnostics["missing_prepared_ligands_examples"], "dropped_missing_prepared_ligands_count": subset_diagnostics["dropped_missing_prepared_ligands_count"], "reference_mode": str(args.reference_mode), "strategies": str(args.strategies).split(","), "comparable": comparable, "reasons": reasons, } _write_json(out_dir / "metrics" / "comparable_benchmark_manifest.json", manifest) report_lines = [ "# benchmark-comparable-adaptive", "", f"- comparable: `{comparable}`", f"- reasons: `{','.join(reasons)}`", f"- evaluation_universe_size: `{len(sampled_rows)}`", f"- requested_evaluation_universe_size: `{subset_diagnostics['requested_evaluation_universe_size']}`", f"- effective_evaluation_universe_size: `{subset_diagnostics['effective_evaluation_universe_size']}`", f"- prepared_sdf_ligand_count: `{subset_diagnostics['prepared_sdf_ligand_count']}`", f"- metadata_ligand_count: `{subset_diagnostics['metadata_ligand_count']}`", f"- missing_prepared_ligands_count: `{subset_diagnostics['missing_prepared_ligands_count']}`", f"- missing_prepared_ligands_examples: `{subset_diagnostics['missing_prepared_ligands_examples']}`", f"- evaluation_universe_dataset_dir: `{subset_dir}`", f"- strategy_run_dir: `{out_dir / 'strategy_runs'}`", ] if comparable: report_lines.append(f"- recommended_strategy_final: `{summary.get('recommended_strategy_final')}`") else: report_lines.append("- gain_reporting: `disabled_until_comparable`") (out_dir / "report.md").write_text("\n".join(report_lines) + "\n", encoding="utf-8") return {"run_dir": str(out_dir), "strategy_payload": strategy_payload, "manifest": manifest} def build_arg_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Run a comparable adaptive docking benchmark on a frozen evaluation universe.") parser.add_argument("--dataset-dir", required=True) parser.add_argument("--evaluation-universe-size", type=int, required=True) parser.add_argument("--evaluation-universe-seed", type=int, default=42) parser.add_argument("--reference-mode", default="full", choices=["full", "sampled", "none"]) parser.add_argument("--reference-sample-size", type=int, default=0) parser.add_argument("--reference-sample-seed", type=int, default=42) parser.add_argument("--strategies", required=True) parser.add_argument("--cost-budget-runs", type=int, required=True) parser.add_argument("--fidelity-levels", default="5,10,15,30,50") parser.add_argument("--promotion-policy", default="quota_ladder") parser.add_argument("--min-final-ligands", type=int, default=200) parser.add_argument("--triage-target-recall", type=float, default=0.95) parser.add_argument("--triage-retain-fraction", type=float, default=0.05) parser.add_argument("--calibration-size", type=int, default=1000) parser.add_argument("--fidelity-validation-size", type=int, default=100) parser.add_argument("--adaptive-policy", default="cluster_bandit") parser.add_argument("--regressor-contribution-mode", default="gate") parser.add_argument("--classifier-weight", type=float, default=1.0) parser.add_argument("--regressor-weight", type=float, default=0.2) parser.add_argument("--cluster-quality-weight", type=float, default=0.4) parser.add_argument("--diversity-weight", type=float, default=0.75) parser.add_argument("--uncertainty-weight", type=float, default=0.2) parser.add_argument("--outlier-risk-weight", type=float, default=2.0) parser.add_argument("--classifier-top-percentile", type=float, default=0.05) parser.add_argument("--classifier-threshold-mode", default="recall_target") parser.add_argument("--classifier-min-positives", type=int, default=10) parser.add_argument("--classifier-holdout-fraction", type=float, default=0.25) parser.add_argument("--classifier-fallback", default="cluster_only") parser.add_argument("--model-fallback-if-worse", default="none") parser.add_argument("--survivor-combination-policy", default="model_only") parser.add_argument("--fixed-score-regressor-name", default="fixed_score_regressor_v1") parser.add_argument("--fixed-score-regressor-target", default="component_sane_affinity_like") parser.add_argument("--regressor-model-type", default="extra_trees") parser.add_argument("--model-validation-split", default="cluster", choices=["random", "cluster"]) parser.add_argument("--diagnostics-level", default="standard", choices=["minimal", "standard", "full"]) parser.add_argument("--classifier-gate-fraction", type=float, default=0.15) parser.add_argument("--classifier-max-gate-fraction", type=float, default=0.2) parser.add_argument("--seeds", default="1,2,3") parser.add_argument("--jobs", default="auto") parser.add_argument("--chunk-size", type=int, default=10) parser.add_argument("--rdock-timeout-seconds", type=int, default=1800) parser.add_argument("--cpu-fraction", type=float, default=0.85) parser.add_argument("--out", required=True) parser.add_argument("--resume", action="store_true") parser.add_argument("--force", action="store_true") return parser def run_from_args(args: argparse.Namespace) -> dict[str, Any]: return benchmark_comparable_adaptive(args)