| 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) |
|
|
