File size: 7,862 Bytes
c289d87 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 | from __future__ import annotations
import json
import shutil
from dataclasses import dataclass
from pathlib import Path
from .provenance import RDockPipelineError, require_file
from .rdock import RDockEngine, TargetConfig
from .sdf import best_per_ligand, parse_rdock_sdf_records, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records
@dataclass
class ScheduledBatch:
batch_index: int
ligand_ids: list[str]
class RealDockingScheduler:
"""Simple explicit scheduler: model ranks candidates, rDock produces ground truth."""
def __init__(self, ligands: object, budget: int, batch_size: int) -> None:
if hasattr(ligands, "to_dict"):
rows = ligands.to_dict(orient="records") # type: ignore[call-arg]
else:
rows = list(ligands) # type: ignore[arg-type]
if not rows or "ligand_id" not in rows[0] or "smiles" not in rows[0]:
raise RDockPipelineError("Adaptive ligand CSV must contain ligand_id and smiles columns")
self.rows: list[dict[str, object]] = [dict(r) for r in rows]
self.budget = int(budget)
self.batch_size = int(batch_size)
self.completed: set[str] = set()
for row in self.rows:
model_score = _float_or_zero(row.get("model_score", 0.0))
row["model_score"] = model_score
row["adaptive_priority"] = -model_score
row["actually_docked"] = False
def next_batch(self) -> ScheduledBatch | None:
remaining_budget = self.budget - len(self.completed)
if remaining_budget <= 0:
return None
active = [row for row in self.rows if str(row["ligand_id"]) not in self.completed]
if not active:
return None
active = sorted(active, key=lambda r: (-float(r["adaptive_priority"]), str(r["ligand_id"])))
ids = [str(row["ligand_id"]) for row in active[: min(self.batch_size, remaining_budget)]]
return ScheduledBatch(batch_index=len(self.completed) // max(1, self.batch_size), ligand_ids=ids)
def update(self, docked_scores: object) -> None:
if hasattr(docked_scores, "to_dict"):
score_rows = docked_scores.to_dict(orient="records") # type: ignore[call-arg]
else:
score_rows = list(docked_scores) # type: ignore[arg-type]
for ligand_id in [str(row["ligand_id"]) for row in score_rows]:
self.completed.add(ligand_id)
for row in self.rows:
if str(row["ligand_id"]) == ligand_id:
row["actually_docked"] = True
if not score_rows:
return
scores = sorted(_float_or_zero(row.get("SCORE", 0.0)) for row in score_rows)
median_score = scores[len(scores) // 2]
for row in self.rows:
if str(row["ligand_id"]) not in self.completed:
row["adaptive_priority"] = float(row["adaptive_priority"]) + (0.001 * -median_score)
def to_dataframe(self):
import pandas as pd
return pd.DataFrame(self.rows)
def _float_or_zero(value: object) -> float:
try:
return float(value)
except Exception:
return 0.0
def _prepare_batch_sdf(ligands: pd.DataFrame, ligand_ids: list[str], out_sdf: Path) -> Path:
from libs.docking.prep import prepare_ligand_sdf
tmp = out_sdf.parent / "prepared"
tmp.mkdir(parents=True, exist_ok=True)
blocks: list[str] = []
by_id = ligands.set_index("ligand_id")
for ligand_id in ligand_ids:
smiles = str(by_id.loc[ligand_id, "smiles"])
sdf = prepare_ligand_sdf(ligand_id, smiles, tmp / f"{ligand_id}.sdf")
blocks.extend(split_sdf_file(sdf))
write_sdf_blocks(blocks, out_sdf)
return out_sdf
def run_adaptive(
target_config: TargetConfig,
ligands_csv: str | Path,
out_dir: str | Path,
budget: int,
batch_size: int,
engine: RDockEngine,
n_runs: int | None = None,
) -> Path:
import pandas as pd
ligands = pd.read_csv(require_file(ligands_csv, "adaptive ligand CSV"))
scheduler = RealDockingScheduler(ligands, budget=budget, batch_size=batch_size)
root = Path(out_dir)
for name in ("target", "ligands", "rdock", "poses", "tables", "metrics"):
(root / name).mkdir(parents=True, exist_ok=True)
shutil.copy2(target_config.receptor, root / "target" / Path(target_config.receptor).name)
shutil.copy2(target_config.reference_ligand, root / "target" / Path(target_config.reference_ligand).name)
batch_records = []
all_blocks: list[str] = []
while True:
batch = scheduler.next_batch()
if batch is None:
break
batch_dir = root / "rdock" / f"batch_{batch.batch_index:03d}"
batch_sdf = _prepare_batch_sdf(ligands, batch.ligand_ids, root / "ligands" / f"batch_{batch.batch_index:03d}.sdf")
artifacts = engine.dock_sdf(target_config, batch_sdf, batch_dir, n_runs=n_runs, jobs=engine.config.jobs, run_id=f"{root.name}_batch_{batch.batch_index:03d}")
best_df = pd.read_csv(artifacts.best_per_ligand_csv)
scheduler.update(best_df)
all_blocks.extend(split_sdf_file(artifacts.all_poses_sdf))
for ligand_id in batch.ligand_ids:
batch_records.append({"batch": batch.batch_index, "ligand_id": ligand_id})
all_poses = root / "poses" / "all_poses.sdf"
write_sdf_blocks(all_blocks, all_poses)
if all_blocks:
records = parse_rdock_sdf_records(all_poses)
best = best_per_ligand(records)
write_sdf_records(best, root / "poses" / "best_per_ligand.sdf")
score_rows = records_to_rows(records)
best_rows = records_to_rows(best)
else:
score_rows = []
best_rows = []
(root / "poses" / "best_per_ligand.sdf").write_text("", encoding="utf-8")
scheduler_df = scheduler.to_dataframe()
model_cols = scheduler_df[["ligand_id", "model_score", "adaptive_priority", "actually_docked"]]
if best_rows:
model_map = model_cols.set_index("ligand_id").to_dict(orient="index")
for row in best_rows:
row.update(model_map.get(str(row["ligand_id"]), {}))
write_rows_csv(score_rows, root / "tables" / "scores_long.csv")
write_rows_csv(best_rows, root / "tables" / "best_per_ligand.csv")
scheduler_df.to_csv(root / "tables" / "scheduler_all_ligands.csv", index=False)
pd.DataFrame(batch_records).to_csv(root / "tables" / "adaptive_batches.csv", index=False)
(root / "metrics" / "validation_metrics.json").write_text("{}", encoding="utf-8")
pd.DataFrame().to_csv(root / "metrics" / "enrichment.csv", index=False)
manifest = {
"engine": "real-rdock-adaptive",
"budget": int(budget),
"batch_size": int(batch_size),
"docked_ligand_count": int(scheduler_df["actually_docked"].sum()),
"undocked_ligands_are_hits": False,
"artifacts": {
"all_poses_sdf": str(all_poses),
"best_per_ligand_csv": str(root / "tables" / "best_per_ligand.csv"),
"scheduler_all_ligands_csv": str(root / "tables" / "scheduler_all_ligands.csv"),
},
}
(root / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
(root / "config.yaml").write_text(f"budget: {budget}\nbatch_size: {batch_size}\n", encoding="utf-8")
(root / "commands.log").write_text("", encoding="utf-8")
for batch_log in sorted((root / "rdock").glob("batch_*/commands.log")):
with (root / "commands.log").open("a", encoding="utf-8") as dst:
dst.write(batch_log.read_text(encoding="utf-8"))
(root / "report.md").write_text(
"# Adaptive rDock Run\n\n"
"Model scores only schedule ligands. `best_per_ligand.csv` is built exclusively from real rDock SDF records with SCORE fields.\n",
encoding="utf-8",
)
return root
|