dualmapref 0.2.8__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- args_parse.py +593 -0
- candidate_corrector.py +161 -0
- candidate_scorer.py +359 -0
- conformend/__init__.py +36 -0
- conformend/refiner.py +25 -0
- dataset/__init__.py +1 -0
- dataset/drugdataset.py +644 -0
- dataset/manifold.py +237 -0
- dataset/sharded_drugdataset.py +124 -0
- dataset/smiles2graph.py +217 -0
- dualmapref/__init__.py +24 -0
- dualmapref/refiner.py +16 -0
- dualmapref-0.2.8.dist-info/LICENSE +21 -0
- dualmapref-0.2.8.dist-info/METADATA +167 -0
- dualmapref-0.2.8.dist-info/RECORD +186 -0
- dualmapref-0.2.8.dist-info/WHEEL +5 -0
- dualmapref-0.2.8.dist-info/entry_points.txt +10 -0
- dualmapref-0.2.8.dist-info/top_level.txt +29 -0
- exputils.py +289 -0
- infer.py +23 -0
- infer_base_conformers.py +5589 -0
- infer_mean_dispersion_torsion.py +1117 -0
- infer_torsion.py +752 -0
- infer_torsional_denoiser.py +1021 -0
- manimol/__init__.py +30 -0
- manimol/__main__.py +6 -0
- manimol/cli.py +36 -0
- manimol/full_cli.py +41 -0
- manimol/legacy_imports.py +43 -0
- manimol/manifest.py +56 -0
- manimol/postprocess.py +148 -0
- manimol/priors.py +60 -0
- manimol/protocols.py +119 -0
- manimol/refiner.py +645 -0
- manimol/runtime.py +194 -0
- manimol/selection.py +85 -0
- manimol/torsion.py +22 -0
- manimol/train_cli.py +14 -0
- mixture_flow/src/__init__.py +1 -0
- mixture_flow/src/_path.py +7 -0
- mixture_flow/src/infer28_mixture_torsion_flow.py +1093 -0
- mixture_flow/src/mixture_torsion_flow.py +291 -0
- mixture_flow/src/summarize_mixture_debug.py +80 -0
- mixture_flow/src/train28_mixture_torsion_flow.py +583 -0
- mixture_torsion_flow.py +7 -0
- models/ manifold_learning.py +86 -0
- models/__init__.py +8 -0
- models/dist.py +273 -0
- models/dist2coords.py +23 -0
- models/egnn.py +107 -0
- models/experimental_backbones.py +364 -0
- models/gnnconv.py +512 -0
- models/kernel_inversion.py +141 -0
- models/kernels.py +427 -0
- models/losses.py +154 -0
- models/mean_dispersion_bridge.py +119 -0
- models/mean_dispersion_torsion_context.py +155 -0
- models/model.py +73 -0
- models/model0.py +2375 -0
- models/vis.py +128 -0
- pgraph_controls.py +107 -0
- scripts/__init__.py +2 -0
- scripts/analyze_basin_alignment.py +63 -0
- scripts/analyze_hif2a_conformer_aggregation.py +267 -0
- scripts/analyze_hif2a_contact_pharmacophore.py +1111 -0
- scripts/analyze_hif2a_fixed_budget.py +202 -0
- scripts/analyze_hif2a_pharmacophore.py +405 -0
- scripts/analyze_hif2a_pharmacophore_match_metric.py +386 -0
- scripts/analyze_p_control_candidate_flow.py +154 -0
- scripts/analyze_scaffold_basin.py +83 -0
- scripts/audit_dispersion_proposals.py +208 -0
- scripts/audit_etflow_protocol.py +258 -0
- scripts/audit_external_overlap.py +150 -0
- scripts/audit_oldbest_fulltrainval_split.py +82 -0
- scripts/audit_pdbbind_contact_pharmacophores.py +146 -0
- scripts/audit_qm9_geomol_test_split.py +94 -0
- scripts/audit_stage1_stage2_cross.py +131 -0
- scripts/build_geom_drugs_lowref_diagnostic.py +84 -0
- scripts/build_qm9_backfill_manifest.py +99 -0
- scripts/check_etflow_runtime.py +56 -0
- scripts/compare_prior_sources.py +122 -0
- scripts/compose_binding_mode_figure.py +87 -0
- scripts/compose_hif2a_contact_pharmacophore_suppfig.py +255 -0
- scripts/compose_hif2a_functional_geometry_pipeline.py +266 -0
- scripts/compose_manimol_internal_architecture.py +291 -0
- scripts/diagnose_flow_basin_intervention.py +54 -0
- scripts/diagnose_hif2a_pharmacophore_budget.py +185 -0
- scripts/diagnose_route2_p_ranking.py +123 -0
- scripts/discover_binding_mode_inputs.py +30 -0
- scripts/evaluate_functional_prior_stage1.py +230 -0
- scripts/evaluate_geomanimol.py +74 -0
- scripts/evaluate_geomanimol_flow.py +23 -0
- scripts/evaluate_geomanimol_multiscaffold.py +46 -0
- scripts/evaluate_geomanimol_residual.py +45 -0
- scripts/evaluate_geomanimol_torsion.py +40 -0
- scripts/evaluate_hif2a_bioactive_enrichment.py +91 -0
- scripts/evaluate_hif2a_pms_suite.py +440 -0
- scripts/evaluate_pdbbind_contact_pms.py +155 -0
- scripts/evaluate_platinum_external.py +114 -0
- scripts/evaluate_platinum_pool.py +82 -0
- scripts/evaluate_route2_calibrated_p.py +104 -0
- scripts/evaluate_route2_library_components.py +596 -0
- scripts/evaluate_route2_p_basin_budget.py +288 -0
- scripts/evaluate_stage1_checkpoint_only.py +30 -0
- scripts/export_dispersion_bond_audit.py +136 -0
- scripts/export_top20_shards.py +207 -0
- scripts/external_validation_metrics.py +152 -0
- scripts/fit_topology_prior.py +117 -0
- scripts/frozen_dispersion_audit.py +281 -0
- scripts/geomanimol_debug.py +50 -0
- scripts/geomanimol_smoke.py +37 -0
- scripts/infer_etflow_matched.py +524 -0
- scripts/inspect_checkpoint.py +12 -0
- scripts/inspect_conformer_capacity.py +71 -0
- scripts/inspect_pool.py +12 -0
- scripts/make_figure3_selection_loss.py +474 -0
- scripts/make_figure3_selection_summary.py +275 -0
- scripts/make_geom_debug_subset.py +62 -0
- scripts/make_low_reference_test_subset.py +70 -0
- scripts/merge_stage1_into_stage2.py +82 -0
- scripts/place_hif2a_candidates_for_evaluation.py +66 -0
- scripts/plot_hif2a_low_budget_efficiency.py +100 -0
- scripts/plot_prior_validation.py +48 -0
- scripts/precompute_stage2_assignments.py +90 -0
- scripts/prepare_bace_activity.py +98 -0
- scripts/prepare_bace_etkdg_benchmark.py +90 -0
- scripts/prepare_figure5_4x4_cases.py +470 -0
- scripts/prepare_geom_drugs_geomol_top20.py +472 -0
- scripts/prepare_pdbbind_core_raw.py +90 -0
- scripts/prepare_platinum_raw.py +74 -0
- scripts/prepare_pubchem_etkdg.py +54 -0
- scripts/rebuild_hif2a_final_sdf_and_metrics.py +55 -0
- scripts/rebuild_hif2a_fixed_pool_sweep.py +175 -0
- scripts/rebuild_hif2a_strict.py +220 -0
- scripts/recompute_hif2a_bootstrap.py +63 -0
- scripts/reference_free_geometry.py +112 -0
- scripts/render_binding_modes.py +413 -0
- scripts/render_figure5_4x4.py +330 -0
- scripts/render_figure6_pharmacophore_pymol.py +162 -0
- scripts/render_hif2a_contact_pharmacophore_pymol.py +414 -0
- scripts/render_hif2a_figure11.py +397 -0
- scripts/run_bace_2d_baseline.py +73 -0
- scripts/run_drugs_validation_matrix.py +225 -0
- scripts/run_external_reference_free.py +53 -0
- scripts/run_manimol_finalk_sensitivity.py +106 -0
- scripts/run_manimol_oversampling_sensitivity.py +109 -0
- scripts/run_pdisp_matched_intervention.py +116 -0
- scripts/run_stage1_stage2_cross20.py +83 -0
- scripts/score_hif2a_candidates_with_pgraph.py +221 -0
- scripts/summarize_dispersion_intervention.py +88 -0
- scripts/test_mean_dispersion_bridge.py +50 -0
- scripts/train_dispersion_head_diagnostic.py +320 -0
- scripts/train_dispersion_head_streaming.py +519 -0
- scripts/train_geomanimol.py +100 -0
- scripts/train_geomanimol_flow.py +26 -0
- scripts/train_geomanimol_residual.py +70 -0
- scripts/train_geomanimol_torsion.py +50 -0
- scripts/train_quantile_representation_diagnostic.py +204 -0
- scripts/validate_mean_dispersion_prior.py +173 -0
- scripts/validate_packed_shard.py +41 -0
- scripts/validate_stage1_prior.py +221 -0
- scripts/validate_top20_shards.py +36 -0
- scripts/validation/__init__.py +1 -0
- scripts/validation/hif2a_downstream_baselines.py +105 -0
- scripts/validation/hif2a_pairwise_ranker.py +218 -0
- scripts/verify_binding_mode_figure.py +47 -0
- torsion_manifold.py +281 -0
- train.py +78 -0
- train_graph_encoder.py +206 -0
- train_local_torsion_corrector.py +511 -0
- train_mean_dispersion_torsion_prior.py +329 -0
- train_probability_basin.py +235 -0
- train_torsion_generator.py +1631 -0
- train_torsion_manifold_prior.py +258 -0
- train_torsional_denoiser.py +415 -0
- trainer.py +1038 -0
- utils/__init__.py +7 -0
- utils/checkpoint.py +40 -0
- utils/device.py +17 -0
- utils/helpers.py +98 -0
- utils/kabsch.py +29 -0
- utils/lookup_table.py +164 -0
- utils/metrics.py +50 -0
- utils/optuna.py +111 -0
- utils/save_mol.py +366 -0
- utils/util.py +36 -0
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
#!/usr/bin/env python
|
|
2
|
+
"""Compare uniform and predicted-weight multi-scaffold residual sampling."""
|
|
3
|
+
|
|
4
|
+
from __future__ import annotations
|
|
5
|
+
|
|
6
|
+
import argparse
|
|
7
|
+
import sys
|
|
8
|
+
from pathlib import Path
|
|
9
|
+
|
|
10
|
+
import torch
|
|
11
|
+
|
|
12
|
+
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
13
|
+
from geomanimol.data import load_molecule_groups
|
|
14
|
+
from geomanimol.residual import ResidualGeoManimol, etkdg_scaffolds
|
|
15
|
+
from scripts.evaluate_geomanimol import distances
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
def main():
|
|
19
|
+
p = argparse.ArgumentParser()
|
|
20
|
+
p.add_argument("--test", default="data/geom_drugs_geomol_top20/geom_drugs_geomol_top20_debug_val.pt")
|
|
21
|
+
p.add_argument("--checkpoint", default="outputs/geomanimol/residual_debug_checkpoint.pt")
|
|
22
|
+
p.add_argument("--molecules", type=int, default=20)
|
|
23
|
+
p.add_argument("--scaffolds", type=int, default=10)
|
|
24
|
+
p.add_argument("--samples", type=int, default=20)
|
|
25
|
+
p.add_argument("--steps", type=int, default=50)
|
|
26
|
+
p.add_argument("--threshold", type=float, default=0.75)
|
|
27
|
+
p.add_argument("--allocation", choices=("uniform", "pi"), default="pi")
|
|
28
|
+
args = p.parse_args()
|
|
29
|
+
mols = load_molecule_groups(args.test, args.molecules)
|
|
30
|
+
ck = torch.load(args.checkpoint, map_location="cpu", weights_only=False); a = ck["args"]
|
|
31
|
+
model = ResidualGeoManimol(a["node_dim"], a["n_basins"], a["manifold_dim"], a["diffusion_steps"])
|
|
32
|
+
model.load_state_dict(ck["model"]); model.eval()
|
|
33
|
+
recall, precision, amr_r, amr_p = [], [], [], []
|
|
34
|
+
for m in mols:
|
|
35
|
+
ss = etkdg_scaffolds(m["mol"], args.scaffolds, 30300 + m["mol_id"] * 100)
|
|
36
|
+
gen = model.generate_from_scaffolds(m, ss, args.samples, args.steps, args.allocation)
|
|
37
|
+
d = distances(m["conformations"], gen); r, q = d.min(1).values, d.min(0).values
|
|
38
|
+
recall.append(float((r <= args.threshold).float().mean())); precision.append(float((q <= args.threshold).float().mean()))
|
|
39
|
+
amr_r.append(float(r.mean())); amr_p.append(float(q.mean()))
|
|
40
|
+
print({"allocation": args.allocation, "molecules": len(mols), "scaffolds": args.scaffolds,
|
|
41
|
+
"samples": args.samples, "threshold": args.threshold, "COV-R": sum(recall)/len(recall),
|
|
42
|
+
"COV-P": sum(precision)/len(precision), "AMR-R": sum(amr_r)/len(amr_r), "AMR-P": sum(amr_p)/len(amr_p)})
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
if __name__ == "__main__":
|
|
46
|
+
main()
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
#!/usr/bin/env python
|
|
2
|
+
"""Evaluate scaffold-relative GeoManimol generation on a small split."""
|
|
3
|
+
|
|
4
|
+
from __future__ import annotations
|
|
5
|
+
|
|
6
|
+
import argparse
|
|
7
|
+
import sys
|
|
8
|
+
from pathlib import Path
|
|
9
|
+
|
|
10
|
+
import torch
|
|
11
|
+
|
|
12
|
+
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
13
|
+
from geomanimol.data import load_molecule_groups
|
|
14
|
+
from geomanimol.residual import ResidualGeoManimol, etkdg_scaffold
|
|
15
|
+
from scripts.evaluate_geomanimol import distances
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
def main():
|
|
19
|
+
p = argparse.ArgumentParser()
|
|
20
|
+
p.add_argument("--test", default="data/geom_drugs_geomol_top20/geom_drugs_geomol_top20_debug_val.pt")
|
|
21
|
+
p.add_argument("--checkpoint", default="outputs/geomanimol/residual_debug_checkpoint.pt")
|
|
22
|
+
p.add_argument("--molecules", type=int, default=20)
|
|
23
|
+
p.add_argument("--samples", type=int, default=8)
|
|
24
|
+
p.add_argument("--steps", type=int, default=50)
|
|
25
|
+
p.add_argument("--threshold", type=float, default=0.75)
|
|
26
|
+
args = p.parse_args()
|
|
27
|
+
mols = load_molecule_groups(args.test, args.molecules)
|
|
28
|
+
ck = torch.load(args.checkpoint, map_location="cpu", weights_only=False); a = ck["args"]
|
|
29
|
+
model = ResidualGeoManimol(a["node_dim"], a["n_basins"], a["manifold_dim"], a["diffusion_steps"])
|
|
30
|
+
model.load_state_dict(ck["model"]); model.eval()
|
|
31
|
+
recall, precision, amr_r, amr_p = [], [], [], []
|
|
32
|
+
for m in mols:
|
|
33
|
+
scaffold = etkdg_scaffold(m["mol"], 30300 + m["mol_id"])
|
|
34
|
+
gen = model.generate(m, scaffold, args.samples, args.steps)
|
|
35
|
+
d = distances(m["conformations"], gen)
|
|
36
|
+
r, q = d.min(1).values, d.min(0).values
|
|
37
|
+
recall.append(float((r <= args.threshold).float().mean())); precision.append(float((q <= args.threshold).float().mean()))
|
|
38
|
+
amr_r.append(float(r.mean())); amr_p.append(float(q.mean()))
|
|
39
|
+
print({"molecules": len(mols), "samples": args.samples, "threshold": args.threshold,
|
|
40
|
+
"COV-R": sum(recall)/len(recall), "COV-P": sum(precision)/len(precision),
|
|
41
|
+
"AMR-R": sum(amr_r)/len(amr_r), "AMR-P": sum(amr_p)/len(amr_p)})
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
if __name__ == "__main__":
|
|
45
|
+
main()
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
#!/usr/bin/env python
|
|
2
|
+
"""Evaluate basin-aware torsion residual diffusion."""
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
import argparse,sys
|
|
5
|
+
from pathlib import Path
|
|
6
|
+
import torch
|
|
7
|
+
sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
|
|
8
|
+
from geomanimol.data import load_molecule_groups
|
|
9
|
+
from geomanimol.residual import etkdg_scaffolds
|
|
10
|
+
from geomanimol.torsion_residual import TorsionResidualGeoManimol
|
|
11
|
+
from scripts.evaluate_geomanimol import distances
|
|
12
|
+
def main():
|
|
13
|
+
p=argparse.ArgumentParser(); p.add_argument('--test',default='data/geom_drugs_geomol_top20/geom_drugs_geomol_top20_debug_val.pt'); p.add_argument('--checkpoint',default='outputs/geomanimol/torsion_debug_checkpoint.pt'); p.add_argument('--molecules',type=int,default=20); p.add_argument('--scaffolds',type=int,default=10); p.add_argument('--samples',type=int,default=20); p.add_argument('--steps',type=int,default=50); p.add_argument('--threshold',type=float,default=.75); p.add_argument('--allocation',choices=('uniform','pi','hybrid'),default='pi'); p.add_argument('--hybrid-alpha',type=float,default=.5); p.add_argument('--condition-mode',choices=('full','no_z','shuffle_z'),default='full'); a=p.parse_args(); ms=load_molecule_groups(a.test,a.molecules); ck=torch.load(a.checkpoint,map_location='cpu',weights_only=False); c=ck['args']; model=TorsionResidualGeoManimol(c['node_dim'],c['n_basins'],c['manifold_dim'],c['diffusion_steps'],c.get('assignment_weight',.5),c.get('basin_weight',.2)); model.load_state_dict(ck['model']); model.eval(); rs=[]; ps=[]; ar=[]; ap=[]
|
|
14
|
+
for m in ms:
|
|
15
|
+
gens=[]
|
|
16
|
+
ss=etkdg_scaffolds(m['mol'],a.scaffolds,30300+m['mol_id']*100)
|
|
17
|
+
if a.allocation == 'uniform':
|
|
18
|
+
counts = [a.samples // len(ss) + (i < a.samples % len(ss)) for i in range(len(ss))]
|
|
19
|
+
elif a.allocation == 'pi':
|
|
20
|
+
weights = torch.stack([model.mode_weights(m, s) for s in ss]); pi = weights.mean(0); desired = torch.floor(pi * a.samples).long();
|
|
21
|
+
while int(desired.sum()) < a.samples: desired[int(torch.argmax(pi * a.samples - desired.float()))] += 1
|
|
22
|
+
modes = weights.argmax(1).tolist(); counts = [0] * len(ss)
|
|
23
|
+
for mode, budget in enumerate(desired.tolist()):
|
|
24
|
+
candidates = [i for i, value in enumerate(modes) if value == mode]
|
|
25
|
+
if not candidates: candidates = list(range(len(ss)))
|
|
26
|
+
for j in range(budget): counts[candidates[j % len(candidates)]] += 1
|
|
27
|
+
else:
|
|
28
|
+
weights = torch.stack([model.mode_weights(m, s) for s in ss]); pi = weights.mean(0)
|
|
29
|
+
blended = a.hybrid_alpha * pi + (1.0 - a.hybrid_alpha) / len(pi)
|
|
30
|
+
desired = torch.floor(blended * a.samples).long()
|
|
31
|
+
while int(desired.sum()) < a.samples: desired[int(torch.argmax(blended * a.samples - desired.float()))] += 1
|
|
32
|
+
modes = weights.argmax(1).tolist(); counts = [0] * len(ss)
|
|
33
|
+
for mode, budget in enumerate(desired.tolist()):
|
|
34
|
+
candidates = [i for i, value in enumerate(modes) if value == mode] or list(range(len(ss)))
|
|
35
|
+
for j in range(budget): counts[candidates[j % len(candidates)]] += 1
|
|
36
|
+
for s, count in zip(ss, counts):
|
|
37
|
+
if count: gens.append(model.generate(m,s,count,a.steps,a.condition_mode))
|
|
38
|
+
g=torch.cat(gens)[:a.samples]; d=distances(m['conformations'],g); r,q=d.min(1).values,d.min(0).values; rs.append(float((r<=a.threshold).float().mean())); ps.append(float((q<=a.threshold).float().mean())); ar.append(float(r.mean())); ap.append(float(q.mean()))
|
|
39
|
+
print({'allocation':a.allocation,'condition_mode':a.condition_mode,'molecules':len(ms),'scaffolds':a.scaffolds,'samples':a.samples,'COV-R':sum(rs)/len(rs),'COV-P':sum(ps)/len(ps),'AMR-R':sum(ar)/len(ar),'AMR-P':sum(ap)/len(ap)})
|
|
40
|
+
if __name__=='__main__': main()
|
|
@@ -0,0 +1,91 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
"""Measure recovery of HIF2A crystallographic ligand conformations."""
|
|
3
|
+
|
|
4
|
+
import argparse
|
|
5
|
+
import csv
|
|
6
|
+
from pathlib import Path
|
|
7
|
+
|
|
8
|
+
import numpy as np
|
|
9
|
+
from rdkit import Chem
|
|
10
|
+
from rdkit.Chem import rdMolAlign
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
def read_first(path):
|
|
14
|
+
mol = Chem.SDMolSupplier(str(path), removeHs=False)[0]
|
|
15
|
+
if mol is None:
|
|
16
|
+
mol = Chem.SDMolSupplier(str(path), removeHs=True)[0]
|
|
17
|
+
if mol is None:
|
|
18
|
+
raise ValueError(f"cannot read {path}")
|
|
19
|
+
return Chem.RemoveHs(mol)
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def best_rmsd(pred, ref):
|
|
23
|
+
return float(rdMolAlign.GetBestRMS(pred, ref))
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def main():
|
|
27
|
+
ap = argparse.ArgumentParser()
|
|
28
|
+
ap.add_argument("--manifest", required=True)
|
|
29
|
+
ap.add_argument("--out_dir", required=True)
|
|
30
|
+
ap.add_argument("--budgets", default="1,5,10,20")
|
|
31
|
+
args = ap.parse_args()
|
|
32
|
+
out_dir = Path(args.out_dir)
|
|
33
|
+
out_dir.mkdir(parents=True, exist_ok=True)
|
|
34
|
+
budgets = [int(x) for x in args.budgets.split(",")]
|
|
35
|
+
rows = []
|
|
36
|
+
with open(args.manifest, newline="") as handle:
|
|
37
|
+
for item in csv.DictReader(handle):
|
|
38
|
+
for method, key in (("etkdg", "etkdg_sdf"), ("manimol", "manimol_sdf")):
|
|
39
|
+
path = item.get(key, "").strip()
|
|
40
|
+
if not path:
|
|
41
|
+
continue
|
|
42
|
+
ref = read_first(item["crystal_ligand_sdf"])
|
|
43
|
+
supplier = Chem.SDMolSupplier(path, removeHs=False)
|
|
44
|
+
scores = []
|
|
45
|
+
for idx, mol in enumerate(supplier):
|
|
46
|
+
if mol is None:
|
|
47
|
+
continue
|
|
48
|
+
try:
|
|
49
|
+
scores.append((idx, best_rmsd(Chem.RemoveHs(mol), ref)))
|
|
50
|
+
except Exception as exc:
|
|
51
|
+
print(f"skip {item['complex_id']} {method} {idx}: {exc}")
|
|
52
|
+
for idx, score in scores:
|
|
53
|
+
rows.append({"complex_id": item["complex_id"], "method": method, "candidate_index": idx, "bioactive_rmsd": score})
|
|
54
|
+
|
|
55
|
+
with open(out_dir / "candidate_bioactive_rmsd.csv", "w", newline="") as handle:
|
|
56
|
+
writer = csv.DictWriter(handle, fieldnames=["complex_id", "method", "candidate_index", "bioactive_rmsd"])
|
|
57
|
+
writer.writeheader()
|
|
58
|
+
writer.writerows(rows)
|
|
59
|
+
|
|
60
|
+
summary = []
|
|
61
|
+
for method in ("etkdg", "manimol"):
|
|
62
|
+
groups = {}
|
|
63
|
+
for row in rows:
|
|
64
|
+
if row["method"] == method:
|
|
65
|
+
groups.setdefault(row["complex_id"], []).append(float(row["bioactive_rmsd"]))
|
|
66
|
+
for budget in budgets:
|
|
67
|
+
values = [min(scores[:budget]) for scores in groups.values() if scores]
|
|
68
|
+
if not values:
|
|
69
|
+
continue
|
|
70
|
+
arr = np.asarray(values, dtype=float)
|
|
71
|
+
summary.append({
|
|
72
|
+
"method": method,
|
|
73
|
+
"budget": budget,
|
|
74
|
+
"n_ligands": len(arr),
|
|
75
|
+
"best_rmsd_mean": float(arr.mean()),
|
|
76
|
+
"best_rmsd_median": float(np.median(arr)),
|
|
77
|
+
"hit_lt_0.5A": float(np.mean(arr < 0.5)),
|
|
78
|
+
"hit_lt_0.75A": float(np.mean(arr < 0.75)),
|
|
79
|
+
"hit_lt_1.0A": float(np.mean(arr < 1.0)),
|
|
80
|
+
"hit_lt_1.5A": float(np.mean(arr < 1.5)),
|
|
81
|
+
})
|
|
82
|
+
with open(out_dir / "bioactive_enrichment_summary.csv", "w", newline="") as handle:
|
|
83
|
+
fields = list(summary[0]) if summary else ["method", "budget"]
|
|
84
|
+
writer = csv.DictWriter(handle, fieldnames=fields)
|
|
85
|
+
writer.writeheader()
|
|
86
|
+
writer.writerows(summary)
|
|
87
|
+
print(f"Saved {len(rows)} candidate scores and {len(summary)} summary rows under {out_dir}")
|
|
88
|
+
|
|
89
|
+
|
|
90
|
+
if __name__ == "__main__":
|
|
91
|
+
main()
|
|
@@ -0,0 +1,440 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
"""Publication-facing diagnostics for the HIF2A pharmacophore match score.
|
|
3
|
+
|
|
4
|
+
The script operates on the candidate-level output produced by
|
|
5
|
+
``analyze_hif2a_pharmacophore_match_metric.py``. It never changes generated
|
|
6
|
+
conformers or the PMS definition. All selector comparisons use the same
|
|
7
|
+
candidate pool and final conformer budget.
|
|
8
|
+
"""
|
|
9
|
+
|
|
10
|
+
from __future__ import annotations
|
|
11
|
+
|
|
12
|
+
import argparse
|
|
13
|
+
import json
|
|
14
|
+
import math
|
|
15
|
+
import os
|
|
16
|
+
import sys
|
|
17
|
+
from pathlib import Path
|
|
18
|
+
|
|
19
|
+
os.environ.setdefault("MPLCONFIGDIR", str(Path("tmp/matplotlib").resolve()))
|
|
20
|
+
|
|
21
|
+
import matplotlib as mpl
|
|
22
|
+
import matplotlib.pyplot as plt
|
|
23
|
+
import numpy as np
|
|
24
|
+
import pandas as pd
|
|
25
|
+
from rdkit import Chem
|
|
26
|
+
from rdkit.Chem import AllChem
|
|
27
|
+
|
|
28
|
+
try:
|
|
29
|
+
from scipy.stats import wilcoxon
|
|
30
|
+
except ImportError: # pragma: no cover - scipy is present in the experiment environment
|
|
31
|
+
wilcoxon = None
|
|
32
|
+
|
|
33
|
+
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
|
|
34
|
+
from analyze_hif2a_contact_pharmacophore import heavy_atom_best_rmsd, read_first_mol
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
COLORS = {"etkdg": "#D28A47", "manimol": "#7961A8"}
|
|
38
|
+
HIT_SCORE = math.exp(-0.5)
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
def parse_json_map(value: str | float) -> dict[str, float]:
|
|
42
|
+
if value is None or (isinstance(value, float) and np.isnan(value)):
|
|
43
|
+
return {}
|
|
44
|
+
try:
|
|
45
|
+
return {str(k): float(v) for k, v in json.loads(str(value)).items()}
|
|
46
|
+
except (TypeError, ValueError, json.JSONDecodeError):
|
|
47
|
+
return {}
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
def candidate_maps(group: pd.DataFrame) -> list[dict[str, dict[str, float]]]:
|
|
51
|
+
return [
|
|
52
|
+
{
|
|
53
|
+
"features": parse_json_map(row.feature_scores_json),
|
|
54
|
+
"pairs": parse_json_map(row.pair_scores_json),
|
|
55
|
+
}
|
|
56
|
+
for row in group.itertuples(index=False)
|
|
57
|
+
]
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def union_metrics(maps: list[dict[str, dict[str, float]]], indices: list[int]) -> dict[str, float]:
|
|
61
|
+
feature_keys = sorted({k for row in maps for k in row["features"]})
|
|
62
|
+
pair_keys = sorted({k for row in maps for k in row["pairs"]})
|
|
63
|
+
feature_best = [max((maps[i]["features"].get(k, 0.0) for i in indices), default=0.0) for k in feature_keys]
|
|
64
|
+
pair_best = [max((maps[i]["pairs"].get(k, 0.0) for i in indices), default=0.0) for k in pair_keys]
|
|
65
|
+
region = float(np.mean(feature_best)) if feature_best else np.nan
|
|
66
|
+
topology = float(np.mean(pair_best)) if pair_best else np.nan
|
|
67
|
+
components = [v for v in (region, topology) if np.isfinite(v)]
|
|
68
|
+
pms = float(np.mean(components)) if components else np.nan
|
|
69
|
+
hits = [float(v >= HIT_SCORE) for v in feature_best + pair_best]
|
|
70
|
+
coverage = float(np.mean(hits)) if hits else np.nan
|
|
71
|
+
return {"pms": pms, "coverage": coverage, "region": region, "topology": topology}
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
def greedy_oracle(maps: list[dict[str, dict[str, float]]], budget: int) -> list[int]:
|
|
75
|
+
selected: list[int] = []
|
|
76
|
+
remaining = set(range(len(maps)))
|
|
77
|
+
for _ in range(min(int(budget), len(maps))):
|
|
78
|
+
best = max(remaining, key=lambda idx: union_metrics(maps, selected + [idx])["pms"])
|
|
79
|
+
selected.append(best)
|
|
80
|
+
remaining.remove(best)
|
|
81
|
+
return selected
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
def mmff_energy(path: str) -> float:
|
|
85
|
+
mol = read_first_mol(Path(path))
|
|
86
|
+
if mol is None:
|
|
87
|
+
return np.nan
|
|
88
|
+
try:
|
|
89
|
+
props = AllChem.MMFFGetMoleculeProperties(mol, mmffVariant="MMFF94s")
|
|
90
|
+
if props is None:
|
|
91
|
+
return np.nan
|
|
92
|
+
ff = AllChem.MMFFGetMoleculeForceField(mol, props, confId=0)
|
|
93
|
+
return float(ff.CalcEnergy()) if ff is not None else np.nan
|
|
94
|
+
except Exception:
|
|
95
|
+
return np.nan
|
|
96
|
+
|
|
97
|
+
|
|
98
|
+
def pairwise_rmsd(group: pd.DataFrame) -> np.ndarray:
|
|
99
|
+
mols = [read_first_mol(Path(path)) for path in group["candidate_file"]]
|
|
100
|
+
n = len(mols)
|
|
101
|
+
matrix = np.full((n, n), np.nan, dtype=float)
|
|
102
|
+
np.fill_diagonal(matrix, 0.0)
|
|
103
|
+
for i in range(n):
|
|
104
|
+
for j in range(i + 1, n):
|
|
105
|
+
value = heavy_atom_best_rmsd(mols[i], mols[j]) if mols[i] is not None and mols[j] is not None else np.nan
|
|
106
|
+
matrix[i, j] = matrix[j, i] = value
|
|
107
|
+
finite = matrix[np.isfinite(matrix)]
|
|
108
|
+
fill = float(np.max(finite)) if finite.size else 10.0
|
|
109
|
+
return np.nan_to_num(matrix, nan=fill, posinf=fill, neginf=fill)
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
def density_centrality_order(group: pd.DataFrame, neighbors: int = 5) -> list[int]:
|
|
113
|
+
matrix = pairwise_rmsd(group)
|
|
114
|
+
n = len(group)
|
|
115
|
+
if n <= 1:
|
|
116
|
+
return list(range(n))
|
|
117
|
+
k = min(max(1, int(neighbors)), n - 1)
|
|
118
|
+
ordered = np.sort(matrix + np.eye(n) * 1e6, axis=1)
|
|
119
|
+
density = 1.0 / (ordered[:, :k].mean(axis=1) + 1e-8)
|
|
120
|
+
centrality = 1.0 / ((matrix.sum(axis=1) / max(1, n - 1)) + 1e-8)
|
|
121
|
+
|
|
122
|
+
def zscore(values: np.ndarray) -> np.ndarray:
|
|
123
|
+
std = float(values.std())
|
|
124
|
+
return (values - values.mean()) / std if std > 1e-12 else np.zeros_like(values)
|
|
125
|
+
|
|
126
|
+
score = zscore(density) + 0.45 * zscore(centrality)
|
|
127
|
+
return np.argsort(-score).tolist()
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def selector_indices(
|
|
131
|
+
selector: str,
|
|
132
|
+
group: pd.DataFrame,
|
|
133
|
+
maps: list[dict[str, dict[str, float]]],
|
|
134
|
+
budget: int,
|
|
135
|
+
rng: np.random.Generator,
|
|
136
|
+
density_order: list[int],
|
|
137
|
+
) -> list[int]:
|
|
138
|
+
count = min(int(budget), len(group))
|
|
139
|
+
if selector == "original_order":
|
|
140
|
+
return list(range(count))
|
|
141
|
+
if selector == "random":
|
|
142
|
+
return rng.permutation(len(group))[:count].tolist()
|
|
143
|
+
if selector == "energy":
|
|
144
|
+
values = group["mmff94s_energy"].to_numpy(float)
|
|
145
|
+
return np.argsort(np.where(np.isfinite(values), values, np.inf))[:count].tolist()
|
|
146
|
+
if selector == "density_centrality":
|
|
147
|
+
return density_order[:count]
|
|
148
|
+
if selector == "oracle_pms":
|
|
149
|
+
return greedy_oracle(maps, count)
|
|
150
|
+
if selector in group.columns:
|
|
151
|
+
return np.argsort(-group[selector].to_numpy(float))[:count].tolist()
|
|
152
|
+
raise ValueError(f"Unknown selector: {selector}")
|
|
153
|
+
|
|
154
|
+
|
|
155
|
+
def write_rmsd_pms_outputs(
|
|
156
|
+
data: pd.DataFrame,
|
|
157
|
+
out: Path,
|
|
158
|
+
high_pms: float,
|
|
159
|
+
low_pms: float,
|
|
160
|
+
high_rmsd: float,
|
|
161
|
+
low_rmsd: float,
|
|
162
|
+
) -> None:
|
|
163
|
+
cases = data.copy()
|
|
164
|
+
cases["case_type"] = ""
|
|
165
|
+
cases.loc[(cases.atom_rmsd >= high_rmsd) & (cases.pharmacophore_match_score >= high_pms), "case_type"] = "high_rmsd_high_pms"
|
|
166
|
+
cases.loc[(cases.atom_rmsd <= low_rmsd) & (cases.pharmacophore_match_score < low_pms), "case_type"] = "low_rmsd_low_pms"
|
|
167
|
+
cases = cases[cases.case_type != ""].copy()
|
|
168
|
+
cases["case_rank"] = cases.groupby(["method", "case_type"])["pharmacophore_match_score"].rank(
|
|
169
|
+
ascending=False, method="first"
|
|
170
|
+
)
|
|
171
|
+
cases.to_csv(out / "rmsd_pms_disagreement_cases.csv", index=False)
|
|
172
|
+
|
|
173
|
+
corr_rows = []
|
|
174
|
+
for method, group in data.groupby("method", sort=True):
|
|
175
|
+
valid = group[["atom_rmsd", "pharmacophore_match_score"]].dropna()
|
|
176
|
+
corr_rows.append(
|
|
177
|
+
{
|
|
178
|
+
"method": method,
|
|
179
|
+
"n_candidates": len(valid),
|
|
180
|
+
"spearman": float(valid.corr(method="spearman").iloc[0, 1]),
|
|
181
|
+
"pearson": float(valid.corr(method="pearson").iloc[0, 1]),
|
|
182
|
+
"high_rmsd_high_pms": int(((group.atom_rmsd >= high_rmsd) & (group.pharmacophore_match_score >= high_pms)).sum()),
|
|
183
|
+
"low_rmsd_low_pms": int(((group.atom_rmsd <= low_rmsd) & (group.pharmacophore_match_score < low_pms)).sum()),
|
|
184
|
+
}
|
|
185
|
+
)
|
|
186
|
+
pd.DataFrame(corr_rows).to_csv(out / "rmsd_pms_correlation_summary.csv", index=False)
|
|
187
|
+
|
|
188
|
+
mpl.rcParams.update({"font.family": "Arial", "font.size": 8, "axes.linewidth": 0.7})
|
|
189
|
+
fig, ax = plt.subplots(figsize=(3.6, 2.8))
|
|
190
|
+
for method, group in data.groupby("method", sort=True):
|
|
191
|
+
ax.scatter(
|
|
192
|
+
group.atom_rmsd,
|
|
193
|
+
group.pharmacophore_match_score,
|
|
194
|
+
s=11,
|
|
195
|
+
alpha=0.55,
|
|
196
|
+
color=COLORS.get(method, "#777777"),
|
|
197
|
+
edgecolors="none",
|
|
198
|
+
label=method.upper() if method == "etkdg" else method.title(),
|
|
199
|
+
)
|
|
200
|
+
ax.axhline(high_pms, color="#B0B0B0", lw=0.7, ls="--")
|
|
201
|
+
ax.axhline(low_pms, color="#D0D0D0", lw=0.6, ls=":")
|
|
202
|
+
ax.axvline(high_rmsd, color="#B0B0B0", lw=0.7, ls="--")
|
|
203
|
+
ax.set(xlabel="Heavy-atom symmetry-aware RMSD (Å)", ylabel="Pharmacophore match score")
|
|
204
|
+
ax.set_ylim(0.0, 1.02)
|
|
205
|
+
ax.spines[["top", "right"]].set_visible(False)
|
|
206
|
+
ax.legend(frameon=False, fontsize=7, loc="lower left")
|
|
207
|
+
fig.tight_layout(pad=0.5)
|
|
208
|
+
for suffix in ("png", "pdf", "svg"):
|
|
209
|
+
fig.savefig(out / f"rmsd_vs_pms.{suffix}", dpi=400 if suffix == "png" else None, bbox_inches="tight")
|
|
210
|
+
plt.close(fig)
|
|
211
|
+
|
|
212
|
+
|
|
213
|
+
def budget_and_selector_outputs(
|
|
214
|
+
data: pd.DataFrame,
|
|
215
|
+
out: Path,
|
|
216
|
+
budgets: list[int],
|
|
217
|
+
pms_threshold: float,
|
|
218
|
+
random_repeats: int,
|
|
219
|
+
seed: int,
|
|
220
|
+
) -> None:
|
|
221
|
+
rng = np.random.default_rng(seed)
|
|
222
|
+
budget_rows = []
|
|
223
|
+
selector_rows = []
|
|
224
|
+
accounting_rows = []
|
|
225
|
+
base_selectors = ["original_order", "random", "energy", "density_centrality", "oracle_pms"]
|
|
226
|
+
|
|
227
|
+
for (method, ligand_id), raw_group in data.groupby(["method", "ligand_id"], sort=True):
|
|
228
|
+
group = raw_group.sort_values("candidate_index").reset_index(drop=True).copy()
|
|
229
|
+
group["mmff94s_energy"] = [mmff_energy(path) for path in group.candidate_file]
|
|
230
|
+
maps = candidate_maps(group)
|
|
231
|
+
density_order = density_centrality_order(group)
|
|
232
|
+
selectors = list(base_selectors)
|
|
233
|
+
selectors.extend(
|
|
234
|
+
name
|
|
235
|
+
for name in ("normal_p_score", "shuffled_p_score", "random_p_score")
|
|
236
|
+
if name in group.columns and group[name].notna().any()
|
|
237
|
+
)
|
|
238
|
+
pool_indices = list(range(len(group)))
|
|
239
|
+
pool_metrics = union_metrics(maps, pool_indices)
|
|
240
|
+
pool_high_fraction = float((group.pharmacophore_match_score >= pms_threshold).mean())
|
|
241
|
+
for budget in budgets:
|
|
242
|
+
original = list(range(min(budget, len(group))))
|
|
243
|
+
original_metrics = union_metrics(maps, original)
|
|
244
|
+
best_pms = float(group.iloc[original].pharmacophore_match_score.max())
|
|
245
|
+
recovery = float(best_pms >= pms_threshold)
|
|
246
|
+
budget_rows.append(
|
|
247
|
+
{
|
|
248
|
+
"method": method,
|
|
249
|
+
"ligand_id": ligand_id,
|
|
250
|
+
"K": budget,
|
|
251
|
+
"pms_at_k": original_metrics["pms"],
|
|
252
|
+
"pharmacophore_coverage_at_k": original_metrics["coverage"],
|
|
253
|
+
"functional_state_recovery_at_k": recovery,
|
|
254
|
+
"best_candidate_pms_at_k": best_pms,
|
|
255
|
+
}
|
|
256
|
+
)
|
|
257
|
+
final_high_fraction = float((group.iloc[original].pharmacophore_match_score >= pms_threshold).mean())
|
|
258
|
+
accounting_rows.append(
|
|
259
|
+
{
|
|
260
|
+
"method": method,
|
|
261
|
+
"ligand_id": ligand_id,
|
|
262
|
+
"K": budget,
|
|
263
|
+
"candidate_pool_size": len(group),
|
|
264
|
+
"candidate_pool_oracle_pms": pool_metrics["pms"],
|
|
265
|
+
"candidate_pool_best_pms": float(group.pharmacophore_match_score.max()),
|
|
266
|
+
"candidate_pool_high_pms_fraction": pool_high_fraction,
|
|
267
|
+
"final_selected_pms": original_metrics["pms"],
|
|
268
|
+
"final_selected_high_pms_fraction": final_high_fraction,
|
|
269
|
+
"selector_enrichment": final_high_fraction / pool_high_fraction if pool_high_fraction > 0 else np.nan,
|
|
270
|
+
}
|
|
271
|
+
)
|
|
272
|
+
for selector in selectors:
|
|
273
|
+
repeats = random_repeats if selector == "random" else 1
|
|
274
|
+
for repeat in range(repeats):
|
|
275
|
+
indices = selector_indices(selector, group, maps, budget, rng, density_order)
|
|
276
|
+
metrics = union_metrics(maps, indices)
|
|
277
|
+
selected_pms = group.iloc[indices].pharmacophore_match_score.to_numpy(float)
|
|
278
|
+
selector_rows.append(
|
|
279
|
+
{
|
|
280
|
+
"method": method,
|
|
281
|
+
"ligand_id": ligand_id,
|
|
282
|
+
"K": budget,
|
|
283
|
+
"selector": selector,
|
|
284
|
+
"repeat": repeat,
|
|
285
|
+
"pms": metrics["pms"],
|
|
286
|
+
"pharmacophore_coverage": metrics["coverage"],
|
|
287
|
+
"functional_state_recovery": float(np.max(selected_pms) >= pms_threshold),
|
|
288
|
+
"high_pms_fraction": float(np.mean(selected_pms >= pms_threshold)),
|
|
289
|
+
}
|
|
290
|
+
)
|
|
291
|
+
|
|
292
|
+
budget_df = pd.DataFrame(budget_rows)
|
|
293
|
+
selector_df = pd.DataFrame(selector_rows)
|
|
294
|
+
accounting_df = pd.DataFrame(accounting_rows)
|
|
295
|
+
budget_summary = budget_df.groupby(["method", "K"], as_index=False).agg(
|
|
296
|
+
n_ligands=("ligand_id", "count"),
|
|
297
|
+
pms_at_k=("pms_at_k", "mean"),
|
|
298
|
+
pharmacophore_coverage_at_k=("pharmacophore_coverage_at_k", "mean"),
|
|
299
|
+
functional_state_recovery_at_k=("functional_state_recovery_at_k", "mean"),
|
|
300
|
+
best_candidate_pms_at_k=("best_candidate_pms_at_k", "mean"),
|
|
301
|
+
)
|
|
302
|
+
auc_rows = []
|
|
303
|
+
for method, group in budget_summary.groupby("method", sort=True):
|
|
304
|
+
group = group.sort_values("K")
|
|
305
|
+
x = np.r_[0.0, group.K.to_numpy(float)]
|
|
306
|
+
for metric in ("pms_at_k", "pharmacophore_coverage_at_k", "functional_state_recovery_at_k"):
|
|
307
|
+
y = np.r_[0.0, group[metric].to_numpy(float)]
|
|
308
|
+
auc_rows.append({"method": method, "metric": metric, "normalized_budget_auc": float(np.trapz(y, x) / x[-1])})
|
|
309
|
+
selector_summary = selector_df.groupby(["method", "K", "selector"], as_index=False).agg(
|
|
310
|
+
n_ligands=("ligand_id", "nunique"),
|
|
311
|
+
pms=("pms", "mean"),
|
|
312
|
+
pharmacophore_coverage=("pharmacophore_coverage", "mean"),
|
|
313
|
+
functional_state_recovery=("functional_state_recovery", "mean"),
|
|
314
|
+
high_pms_fraction=("high_pms_fraction", "mean"),
|
|
315
|
+
)
|
|
316
|
+
accounting_summary = accounting_df.groupby(["method", "K"], as_index=False).agg(
|
|
317
|
+
n_ligands=("ligand_id", "count"),
|
|
318
|
+
candidate_pool_oracle_pms=("candidate_pool_oracle_pms", "mean"),
|
|
319
|
+
candidate_pool_best_pms=("candidate_pool_best_pms", "mean"),
|
|
320
|
+
final_selected_pms=("final_selected_pms", "mean"),
|
|
321
|
+
selector_enrichment=("selector_enrichment", "mean"),
|
|
322
|
+
)
|
|
323
|
+
|
|
324
|
+
budget_df.to_csv(out / "budget_scaling_per_ligand.csv", index=False)
|
|
325
|
+
budget_summary.to_csv(out / "budget_scaling_summary.csv", index=False)
|
|
326
|
+
pd.DataFrame(auc_rows).to_csv(out / "budget_auc_summary.csv", index=False)
|
|
327
|
+
selector_df.to_csv(out / "fixed_pool_selector_per_ligand.csv", index=False)
|
|
328
|
+
selector_summary.to_csv(out / "fixed_pool_selector_summary.csv", index=False)
|
|
329
|
+
accounting_df.to_csv(out / "generation_selection_accounting_per_ligand.csv", index=False)
|
|
330
|
+
accounting_summary.to_csv(out / "generation_selection_accounting_summary.csv", index=False)
|
|
331
|
+
|
|
332
|
+
p_stats = []
|
|
333
|
+
p_only = selector_df[
|
|
334
|
+
selector_df.selector.isin(["normal_p_score", "shuffled_p_score", "random_p_score"])
|
|
335
|
+
]
|
|
336
|
+
for (method, budget), group in p_only.groupby(["method", "K"], sort=True):
|
|
337
|
+
pivot = group.pivot_table(index="ligand_id", columns="selector", values="pms", aggfunc="mean")
|
|
338
|
+
if "normal_p_score" not in pivot:
|
|
339
|
+
continue
|
|
340
|
+
for control in ("shuffled_p_score", "random_p_score"):
|
|
341
|
+
if control not in pivot:
|
|
342
|
+
continue
|
|
343
|
+
delta = (pivot["normal_p_score"] - pivot[control]).dropna()
|
|
344
|
+
p_value = np.nan
|
|
345
|
+
if wilcoxon is not None and len(delta) > 0 and np.any(np.abs(delta.to_numpy()) > 1e-12):
|
|
346
|
+
p_value = float(wilcoxon(delta, alternative="greater").pvalue)
|
|
347
|
+
p_stats.append(
|
|
348
|
+
{
|
|
349
|
+
"method": method,
|
|
350
|
+
"K": budget,
|
|
351
|
+
"comparison": f"normal_minus_{control.replace('_p_score', '')}",
|
|
352
|
+
"n_ligands": len(delta),
|
|
353
|
+
"mean_pms_delta": float(delta.mean()),
|
|
354
|
+
"median_pms_delta": float(delta.median()),
|
|
355
|
+
"normal_wins": int((delta > 0).sum()),
|
|
356
|
+
"ties": int((delta == 0).sum()),
|
|
357
|
+
"wilcoxon_greater_p": p_value,
|
|
358
|
+
}
|
|
359
|
+
)
|
|
360
|
+
pd.DataFrame(p_stats).to_csv(out / "p_control_paired_statistics.csv", index=False)
|
|
361
|
+
|
|
362
|
+
fig, axes = plt.subplots(1, 3, figsize=(7.4, 2.25), sharex=True)
|
|
363
|
+
metrics = [
|
|
364
|
+
("pms_at_k", "PMS@K"),
|
|
365
|
+
("pharmacophore_coverage_at_k", "Pharmacophore coverage@K"),
|
|
366
|
+
("functional_state_recovery_at_k", "Functional-state recovery@K"),
|
|
367
|
+
]
|
|
368
|
+
for ax, (metric, label) in zip(axes, metrics):
|
|
369
|
+
for method, group in budget_summary.groupby("method", sort=True):
|
|
370
|
+
group = group.sort_values("K")
|
|
371
|
+
ax.plot(group.K, group[metric], marker="o", ms=3.5, lw=1.4, color=COLORS.get(method, "#777777"), label=method.upper() if method == "etkdg" else method.title())
|
|
372
|
+
ax.set_title(label, fontsize=8)
|
|
373
|
+
ax.set_xticks(budgets)
|
|
374
|
+
ax.set_ylim(0.0, 1.02)
|
|
375
|
+
ax.spines[["top", "right"]].set_visible(False)
|
|
376
|
+
ax.grid(axis="y", color="#E5E5E5", lw=0.5)
|
|
377
|
+
axes[0].set_ylabel("Score")
|
|
378
|
+
axes[1].set_xlabel("Conformer budget K")
|
|
379
|
+
axes[-1].legend(frameon=False, fontsize=6.5, loc="lower right")
|
|
380
|
+
fig.tight_layout(pad=0.55, w_pad=0.9)
|
|
381
|
+
for suffix in ("png", "pdf", "svg"):
|
|
382
|
+
fig.savefig(out / f"pms_budget_scaling.{suffix}", dpi=400 if suffix == "png" else None, bbox_inches="tight")
|
|
383
|
+
plt.close(fig)
|
|
384
|
+
|
|
385
|
+
availability = {
|
|
386
|
+
"normal_p_selector": "normal_p_score" in data.columns,
|
|
387
|
+
"shuffled_p_selector": "shuffled_p_score" in data.columns,
|
|
388
|
+
"random_p_selector": "random_p_score" in data.columns,
|
|
389
|
+
"note": "P controls require per-candidate scores on the same fixed HIF2A candidate pool.",
|
|
390
|
+
}
|
|
391
|
+
(out / "p_control_selector_availability.json").write_text(json.dumps(availability, indent=2) + "\n")
|
|
392
|
+
|
|
393
|
+
|
|
394
|
+
def main() -> None:
|
|
395
|
+
parser = argparse.ArgumentParser(description="HIF2A PMS diagnostic suite")
|
|
396
|
+
parser.add_argument("--input", default="outputs/docking/hif2a_pharmacophore_match_metric/candidate_pharmacophore_match_scores.csv")
|
|
397
|
+
parser.add_argument("--output_dir", default="outputs/docking/hif2a_pms_suite")
|
|
398
|
+
parser.add_argument("--budgets", default="1,5,10,20")
|
|
399
|
+
parser.add_argument("--pms_threshold", type=float, default=0.8)
|
|
400
|
+
parser.add_argument("--case_high_pms", type=float, default=0.9)
|
|
401
|
+
parser.add_argument("--case_low_pms", type=float, default=0.85)
|
|
402
|
+
parser.add_argument("--high_rmsd", type=float, default=1.5)
|
|
403
|
+
parser.add_argument("--low_rmsd", type=float, default=0.75)
|
|
404
|
+
parser.add_argument("--random_repeats", type=int, default=100)
|
|
405
|
+
parser.add_argument("--seed", type=int, default=20260825)
|
|
406
|
+
args = parser.parse_args()
|
|
407
|
+
|
|
408
|
+
output_dir = Path(args.output_dir)
|
|
409
|
+
output_dir.mkdir(parents=True, exist_ok=True)
|
|
410
|
+
data = pd.read_csv(args.input).sort_values(["method", "ligand_id", "candidate_index"]).reset_index(drop=True)
|
|
411
|
+
budgets = sorted({int(v) for v in args.budgets.split(",") if v.strip()})
|
|
412
|
+
write_rmsd_pms_outputs(
|
|
413
|
+
data,
|
|
414
|
+
output_dir,
|
|
415
|
+
args.case_high_pms,
|
|
416
|
+
args.case_low_pms,
|
|
417
|
+
args.high_rmsd,
|
|
418
|
+
args.low_rmsd,
|
|
419
|
+
)
|
|
420
|
+
budget_and_selector_outputs(data, output_dir, budgets, args.pms_threshold, args.random_repeats, args.seed)
|
|
421
|
+
config = {
|
|
422
|
+
**vars(args),
|
|
423
|
+
"candidate_rows": int(len(data)),
|
|
424
|
+
"ligands": int(data.ligand_id.nunique()),
|
|
425
|
+
"methods": sorted(data.method.unique().tolist()),
|
|
426
|
+
"pharmacophore_hit_score_threshold": HIT_SCORE,
|
|
427
|
+
"energy_selector": "MMFF94s single-point energy; no geometry optimization",
|
|
428
|
+
"density_selector": "within-ligand candidate RMSD density plus 0.45 centrality",
|
|
429
|
+
"oracle_warning": "Oracle PMS uses target pharmacophore information and is an upper bound only.",
|
|
430
|
+
}
|
|
431
|
+
(output_dir / "pms_suite_config.json").write_text(json.dumps(config, indent=2) + "\n")
|
|
432
|
+
print(pd.read_csv(output_dir / "rmsd_pms_correlation_summary.csv").to_string(index=False))
|
|
433
|
+
print(pd.read_csv(output_dir / "budget_scaling_summary.csv").to_string(index=False))
|
|
434
|
+
print(pd.read_csv(output_dir / "budget_auc_summary.csv").to_string(index=False))
|
|
435
|
+
print(pd.read_csv(output_dir / "generation_selection_accounting_summary.csv").to_string(index=False))
|
|
436
|
+
print(f"Saved outputs under {output_dir}")
|
|
437
|
+
|
|
438
|
+
|
|
439
|
+
if __name__ == "__main__":
|
|
440
|
+
main()
|