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.
Files changed (186) hide show
  1. args_parse.py +593 -0
  2. candidate_corrector.py +161 -0
  3. candidate_scorer.py +359 -0
  4. conformend/__init__.py +36 -0
  5. conformend/refiner.py +25 -0
  6. dataset/__init__.py +1 -0
  7. dataset/drugdataset.py +644 -0
  8. dataset/manifold.py +237 -0
  9. dataset/sharded_drugdataset.py +124 -0
  10. dataset/smiles2graph.py +217 -0
  11. dualmapref/__init__.py +24 -0
  12. dualmapref/refiner.py +16 -0
  13. dualmapref-0.2.8.dist-info/LICENSE +21 -0
  14. dualmapref-0.2.8.dist-info/METADATA +167 -0
  15. dualmapref-0.2.8.dist-info/RECORD +186 -0
  16. dualmapref-0.2.8.dist-info/WHEEL +5 -0
  17. dualmapref-0.2.8.dist-info/entry_points.txt +10 -0
  18. dualmapref-0.2.8.dist-info/top_level.txt +29 -0
  19. exputils.py +289 -0
  20. infer.py +23 -0
  21. infer_base_conformers.py +5589 -0
  22. infer_mean_dispersion_torsion.py +1117 -0
  23. infer_torsion.py +752 -0
  24. infer_torsional_denoiser.py +1021 -0
  25. manimol/__init__.py +30 -0
  26. manimol/__main__.py +6 -0
  27. manimol/cli.py +36 -0
  28. manimol/full_cli.py +41 -0
  29. manimol/legacy_imports.py +43 -0
  30. manimol/manifest.py +56 -0
  31. manimol/postprocess.py +148 -0
  32. manimol/priors.py +60 -0
  33. manimol/protocols.py +119 -0
  34. manimol/refiner.py +645 -0
  35. manimol/runtime.py +194 -0
  36. manimol/selection.py +85 -0
  37. manimol/torsion.py +22 -0
  38. manimol/train_cli.py +14 -0
  39. mixture_flow/src/__init__.py +1 -0
  40. mixture_flow/src/_path.py +7 -0
  41. mixture_flow/src/infer28_mixture_torsion_flow.py +1093 -0
  42. mixture_flow/src/mixture_torsion_flow.py +291 -0
  43. mixture_flow/src/summarize_mixture_debug.py +80 -0
  44. mixture_flow/src/train28_mixture_torsion_flow.py +583 -0
  45. mixture_torsion_flow.py +7 -0
  46. models/ manifold_learning.py +86 -0
  47. models/__init__.py +8 -0
  48. models/dist.py +273 -0
  49. models/dist2coords.py +23 -0
  50. models/egnn.py +107 -0
  51. models/experimental_backbones.py +364 -0
  52. models/gnnconv.py +512 -0
  53. models/kernel_inversion.py +141 -0
  54. models/kernels.py +427 -0
  55. models/losses.py +154 -0
  56. models/mean_dispersion_bridge.py +119 -0
  57. models/mean_dispersion_torsion_context.py +155 -0
  58. models/model.py +73 -0
  59. models/model0.py +2375 -0
  60. models/vis.py +128 -0
  61. pgraph_controls.py +107 -0
  62. scripts/__init__.py +2 -0
  63. scripts/analyze_basin_alignment.py +63 -0
  64. scripts/analyze_hif2a_conformer_aggregation.py +267 -0
  65. scripts/analyze_hif2a_contact_pharmacophore.py +1111 -0
  66. scripts/analyze_hif2a_fixed_budget.py +202 -0
  67. scripts/analyze_hif2a_pharmacophore.py +405 -0
  68. scripts/analyze_hif2a_pharmacophore_match_metric.py +386 -0
  69. scripts/analyze_p_control_candidate_flow.py +154 -0
  70. scripts/analyze_scaffold_basin.py +83 -0
  71. scripts/audit_dispersion_proposals.py +208 -0
  72. scripts/audit_etflow_protocol.py +258 -0
  73. scripts/audit_external_overlap.py +150 -0
  74. scripts/audit_oldbest_fulltrainval_split.py +82 -0
  75. scripts/audit_pdbbind_contact_pharmacophores.py +146 -0
  76. scripts/audit_qm9_geomol_test_split.py +94 -0
  77. scripts/audit_stage1_stage2_cross.py +131 -0
  78. scripts/build_geom_drugs_lowref_diagnostic.py +84 -0
  79. scripts/build_qm9_backfill_manifest.py +99 -0
  80. scripts/check_etflow_runtime.py +56 -0
  81. scripts/compare_prior_sources.py +122 -0
  82. scripts/compose_binding_mode_figure.py +87 -0
  83. scripts/compose_hif2a_contact_pharmacophore_suppfig.py +255 -0
  84. scripts/compose_hif2a_functional_geometry_pipeline.py +266 -0
  85. scripts/compose_manimol_internal_architecture.py +291 -0
  86. scripts/diagnose_flow_basin_intervention.py +54 -0
  87. scripts/diagnose_hif2a_pharmacophore_budget.py +185 -0
  88. scripts/diagnose_route2_p_ranking.py +123 -0
  89. scripts/discover_binding_mode_inputs.py +30 -0
  90. scripts/evaluate_functional_prior_stage1.py +230 -0
  91. scripts/evaluate_geomanimol.py +74 -0
  92. scripts/evaluate_geomanimol_flow.py +23 -0
  93. scripts/evaluate_geomanimol_multiscaffold.py +46 -0
  94. scripts/evaluate_geomanimol_residual.py +45 -0
  95. scripts/evaluate_geomanimol_torsion.py +40 -0
  96. scripts/evaluate_hif2a_bioactive_enrichment.py +91 -0
  97. scripts/evaluate_hif2a_pms_suite.py +440 -0
  98. scripts/evaluate_pdbbind_contact_pms.py +155 -0
  99. scripts/evaluate_platinum_external.py +114 -0
  100. scripts/evaluate_platinum_pool.py +82 -0
  101. scripts/evaluate_route2_calibrated_p.py +104 -0
  102. scripts/evaluate_route2_library_components.py +596 -0
  103. scripts/evaluate_route2_p_basin_budget.py +288 -0
  104. scripts/evaluate_stage1_checkpoint_only.py +30 -0
  105. scripts/export_dispersion_bond_audit.py +136 -0
  106. scripts/export_top20_shards.py +207 -0
  107. scripts/external_validation_metrics.py +152 -0
  108. scripts/fit_topology_prior.py +117 -0
  109. scripts/frozen_dispersion_audit.py +281 -0
  110. scripts/geomanimol_debug.py +50 -0
  111. scripts/geomanimol_smoke.py +37 -0
  112. scripts/infer_etflow_matched.py +524 -0
  113. scripts/inspect_checkpoint.py +12 -0
  114. scripts/inspect_conformer_capacity.py +71 -0
  115. scripts/inspect_pool.py +12 -0
  116. scripts/make_figure3_selection_loss.py +474 -0
  117. scripts/make_figure3_selection_summary.py +275 -0
  118. scripts/make_geom_debug_subset.py +62 -0
  119. scripts/make_low_reference_test_subset.py +70 -0
  120. scripts/merge_stage1_into_stage2.py +82 -0
  121. scripts/place_hif2a_candidates_for_evaluation.py +66 -0
  122. scripts/plot_hif2a_low_budget_efficiency.py +100 -0
  123. scripts/plot_prior_validation.py +48 -0
  124. scripts/precompute_stage2_assignments.py +90 -0
  125. scripts/prepare_bace_activity.py +98 -0
  126. scripts/prepare_bace_etkdg_benchmark.py +90 -0
  127. scripts/prepare_figure5_4x4_cases.py +470 -0
  128. scripts/prepare_geom_drugs_geomol_top20.py +472 -0
  129. scripts/prepare_pdbbind_core_raw.py +90 -0
  130. scripts/prepare_platinum_raw.py +74 -0
  131. scripts/prepare_pubchem_etkdg.py +54 -0
  132. scripts/rebuild_hif2a_final_sdf_and_metrics.py +55 -0
  133. scripts/rebuild_hif2a_fixed_pool_sweep.py +175 -0
  134. scripts/rebuild_hif2a_strict.py +220 -0
  135. scripts/recompute_hif2a_bootstrap.py +63 -0
  136. scripts/reference_free_geometry.py +112 -0
  137. scripts/render_binding_modes.py +413 -0
  138. scripts/render_figure5_4x4.py +330 -0
  139. scripts/render_figure6_pharmacophore_pymol.py +162 -0
  140. scripts/render_hif2a_contact_pharmacophore_pymol.py +414 -0
  141. scripts/render_hif2a_figure11.py +397 -0
  142. scripts/run_bace_2d_baseline.py +73 -0
  143. scripts/run_drugs_validation_matrix.py +225 -0
  144. scripts/run_external_reference_free.py +53 -0
  145. scripts/run_manimol_finalk_sensitivity.py +106 -0
  146. scripts/run_manimol_oversampling_sensitivity.py +109 -0
  147. scripts/run_pdisp_matched_intervention.py +116 -0
  148. scripts/run_stage1_stage2_cross20.py +83 -0
  149. scripts/score_hif2a_candidates_with_pgraph.py +221 -0
  150. scripts/summarize_dispersion_intervention.py +88 -0
  151. scripts/test_mean_dispersion_bridge.py +50 -0
  152. scripts/train_dispersion_head_diagnostic.py +320 -0
  153. scripts/train_dispersion_head_streaming.py +519 -0
  154. scripts/train_geomanimol.py +100 -0
  155. scripts/train_geomanimol_flow.py +26 -0
  156. scripts/train_geomanimol_residual.py +70 -0
  157. scripts/train_geomanimol_torsion.py +50 -0
  158. scripts/train_quantile_representation_diagnostic.py +204 -0
  159. scripts/validate_mean_dispersion_prior.py +173 -0
  160. scripts/validate_packed_shard.py +41 -0
  161. scripts/validate_stage1_prior.py +221 -0
  162. scripts/validate_top20_shards.py +36 -0
  163. scripts/validation/__init__.py +1 -0
  164. scripts/validation/hif2a_downstream_baselines.py +105 -0
  165. scripts/validation/hif2a_pairwise_ranker.py +218 -0
  166. scripts/verify_binding_mode_figure.py +47 -0
  167. torsion_manifold.py +281 -0
  168. train.py +78 -0
  169. train_graph_encoder.py +206 -0
  170. train_local_torsion_corrector.py +511 -0
  171. train_mean_dispersion_torsion_prior.py +329 -0
  172. train_probability_basin.py +235 -0
  173. train_torsion_generator.py +1631 -0
  174. train_torsion_manifold_prior.py +258 -0
  175. train_torsional_denoiser.py +415 -0
  176. trainer.py +1038 -0
  177. utils/__init__.py +7 -0
  178. utils/checkpoint.py +40 -0
  179. utils/device.py +17 -0
  180. utils/helpers.py +98 -0
  181. utils/kabsch.py +29 -0
  182. utils/lookup_table.py +164 -0
  183. utils/metrics.py +50 -0
  184. utils/optuna.py +111 -0
  185. utils/save_mol.py +366 -0
  186. utils/util.py +36 -0
models/vis.py ADDED
@@ -0,0 +1,128 @@
1
+ from rdkit import Chem
2
+ from rdkit.Chem import AllChem
3
+ import py3Dmol
4
+ import numpy as np
5
+
6
+
7
+
8
+ from PIL import Image
9
+ import imageio
10
+
11
+ def visualize_molecule_with_coords(smiles, coords):
12
+ """
13
+ Visualize a molecule with 3D coordinates (excluding hydrogens) using py3Dmol,
14
+ and label each atom with its atomic index.
15
+
16
+ Args:
17
+ smiles (str): SMILES string of the molecule
18
+ coords (np.ndarray): (N_atoms_noH, 3) array of 3D coordinates
19
+ """
20
+ from rdkit import Chem
21
+ import py3Dmol
22
+
23
+ mol = Chem.MolFromSmiles(smiles)
24
+ mol = Chem.RemoveHs(mol) # remove hydrogens to match coordinate shape
25
+
26
+ if mol.GetNumAtoms() != coords.shape[0]:
27
+ raise ValueError(f"Number of non-H atoms in molecule ({mol.GetNumAtoms()}) does not match coordinate shape {coords.shape}")
28
+
29
+ # Write coordinates to conformer
30
+ conf = Chem.Conformer(mol.GetNumAtoms())
31
+ for i in range(mol.GetNumAtoms()):
32
+ x, y, z = coords[i]
33
+ conf.SetAtomPosition(i, (float(x), float(y), float(z)))
34
+
35
+ mol.RemoveAllConformers()
36
+ mol.AddConformer(conf)
37
+
38
+ # Generate mol block with 3D coordinates
39
+ block = Chem.MolToMolBlock(mol)
40
+
41
+ # Visualization with atom index labels
42
+ viewer = py3Dmol.view(width=400, height=400)
43
+ viewer.addModel(block, 'mol')
44
+ viewer.setStyle({'stick': {}})
45
+
46
+ # Add index labels instead of atomic symbols
47
+ for i in range(mol.GetNumAtoms()):
48
+ pos = coords[i]
49
+ viewer.addLabel(str(i), {
50
+ 'position': {'x': float(pos[0]), 'y': float(pos[1]), 'z': float(pos[2])},
51
+ 'backgroundColor': 'white',
52
+ 'fontColor': 'black',
53
+ 'fontSize': 14,
54
+ 'showBackground': False
55
+ })
56
+
57
+ viewer.setBackgroundColor('white')
58
+ viewer.zoomTo()
59
+ viewer.rotate(90, {'x':1,'y':0,'z':0})
60
+ return viewer.show()
61
+
62
+
63
+ import os
64
+ import numpy as np
65
+ import py3Dmol
66
+ from rdkit import Chem
67
+ from rdkit.Chem import AllChem, Draw
68
+
69
+ def visualize_and_save_frame(smiles, coords, filename,):
70
+ """
71
+ Visualize a molecule with given coordinates and save as PNG.
72
+ If py3Dmol can't instantiate a viewer (e.g., headless), optionally fall back to RDKit 2D.
73
+
74
+ Args:
75
+ smiles (str): SMILES string
76
+ coords (np.ndarray): (N_atoms, 3) coordinates
77
+ filename (str): path to save image
78
+ show (bool): if True, display viewer in Jupyter
79
+ fallback_2d (bool): use RDKit 2D if py3Dmol PNG fails
80
+ size (int): image width/height in pixels
81
+ """
82
+ # Build molecule and set coordinates
83
+ mol = Chem.MolFromSmiles(smiles)
84
+ if mol is None:
85
+ raise ValueError("Invalid SMILES.")
86
+ #mol = Chem.AddHs(mol) # ensure atom count matches coordinates if coords include H
87
+ if coords.shape != (mol.GetNumAtoms(), 3):
88
+ # If your coords are heavy-atom only, remove Hs instead:
89
+ # mol = Chem.RemoveHs(mol)
90
+ # (then re-check shape)
91
+ raise ValueError(f"Atom/coord mismatch: mol has {mol.GetNumAtoms()} atoms, coords are {coords.shape}")
92
+
93
+ conf = Chem.Conformer(mol.GetNumAtoms())
94
+ for i in range(mol.GetNumAtoms()):
95
+ x, y, z = float(coords[i,0]), float(coords[i,1]), float(coords[i,2])
96
+ conf.SetAtomPosition(i, (x, y, z))
97
+ mol.RemoveAllConformers()
98
+ mol.AddConformer(conf, assignId=True)
99
+
100
+ # Prepare 3D display via py3Dmol
101
+ block = Chem.MolToMolBlock(mol)
102
+ viewer = py3Dmol.view(width=800, height=800)
103
+ viewer.addModel(block, 'sdf') # MolBlock is SDF format
104
+ viewer.setStyle({'stick': {}})
105
+ viewer.setBackgroundColor('white')
106
+ viewer.zoomTo()
107
+ viewer.rotate(90, {'x':1,'y':0,'z':0})
108
+ viewer.write_html(f=f'{filename}.html', fullpage = True)
109
+ png=viewer.png()
110
+ with open(f'{filename}.png', 'wb') as f:
111
+ f.write(png)
112
+
113
+
114
+
115
+ def make_video_from_frames(folder, output_path='video.mp4', fps=10):
116
+ """
117
+ Combine PNG frames in folder into a single video using imageio.
118
+
119
+ Args:
120
+ folder (str): folder containing PNGs
121
+ output_path (str): output .mp4 file path
122
+ fps (int): frames per second
123
+ """
124
+ files = sorted([
125
+ os.path.join(folder, f) for f in os.listdir(folder) if f.endswith('.png')
126
+ ])
127
+ images = [Image.open(f) for f in files]
128
+ imageio.mimsave(output_path, images, fps=fps)
pgraph_controls.py ADDED
@@ -0,0 +1,107 @@
1
+ """Controlled probability-graph baselines used by causal P diagnostics.
2
+
3
+ These transforms preserve the tensor shape and symmetry of a learned
4
+ pairwise-proximity map while selectively removing atom-pair semantics.
5
+ They are diagnostics, not inference-time model variants.
6
+ """
7
+
8
+ from __future__ import annotations
9
+
10
+ from collections import deque
11
+ import json
12
+
13
+ import torch
14
+
15
+
16
+ def symmetrize_probability(P: torch.Tensor) -> torch.Tensor:
17
+ P = 0.5 * (P + P.t())
18
+ P = P.clone()
19
+ P.fill_diagonal_(0.0)
20
+ return P
21
+
22
+
23
+ def _off_diagonal_values(P: torch.Tensor) -> torch.Tensor:
24
+ mask = torch.triu(torch.ones_like(P, dtype=torch.bool), diagonal=1)
25
+ values = P[mask]
26
+ return values[torch.isfinite(values)]
27
+
28
+
29
+ def _topological_distances(mol, n_atoms: int, device) -> torch.Tensor:
30
+ dist = torch.full((n_atoms, n_atoms), float(n_atoms + 1), device=device)
31
+ dist.fill_diagonal_(0.0)
32
+ if mol is None or int(mol.GetNumAtoms()) != n_atoms:
33
+ return dist
34
+ adjacency = [[] for _ in range(n_atoms)]
35
+ for bond in mol.GetBonds():
36
+ i, j = int(bond.GetBeginAtomIdx()), int(bond.GetEndAtomIdx())
37
+ if 0 <= i < n_atoms and 0 <= j < n_atoms:
38
+ adjacency[i].append(j)
39
+ adjacency[j].append(i)
40
+ for source in range(n_atoms):
41
+ queue = deque([source])
42
+ seen = {source}
43
+ while queue:
44
+ node = queue.popleft()
45
+ for nxt in adjacency[node]:
46
+ if nxt not in seen:
47
+ seen.add(nxt)
48
+ dist[source, nxt] = dist[source, node] + 1.0
49
+ queue.append(nxt)
50
+ return dist
51
+
52
+
53
+ def controlled_pglobal(P: torch.Tensor, args, mol=None) -> torch.Tensor:
54
+ """Return a controlled P map with the learned-map value range retained."""
55
+ if P is None:
56
+ return None
57
+ if bool(getattr(args, "disable_stage1_pglobal", False)):
58
+ return torch.zeros_like(P)
59
+
60
+ mode = str(getattr(args, "pglobal_control", "normal") or "normal").lower()
61
+ if mode == "normal":
62
+ return P
63
+ if mode == "zero":
64
+ return torch.zeros_like(P)
65
+
66
+ seed = int(getattr(args, "pglobal_seed", 20260719))
67
+ seed = (seed + int(P.numel()) * 1009 + int(P.shape[0]) * 9173) % (2**31 - 1)
68
+ generator = torch.Generator(device=P.device)
69
+ generator.manual_seed(seed)
70
+ values = _off_diagonal_values(P).detach().float()
71
+ median = torch.median(values).to(dtype=P.dtype) if values.numel() else P.new_tensor(0.5)
72
+
73
+ if mode == "constant":
74
+ return symmetrize_probability(torch.full_like(P, median))
75
+ if mode == "shuffle":
76
+ perm = torch.randperm(P.shape[0], generator=generator, device=P.device)
77
+ return symmetrize_probability(P[perm][:, perm])
78
+ if mode == "random":
79
+ random_map = torch.rand(P.shape, generator=generator, device=P.device, dtype=P.dtype)
80
+ if values.numel() > 1:
81
+ lo = torch.quantile(values, 0.05).to(dtype=P.dtype)
82
+ hi = torch.quantile(values, 0.95).to(dtype=P.dtype)
83
+ random_map = lo + (hi - lo).clamp_min(1e-6) * random_map
84
+ return symmetrize_probability(random_map.clamp(0.0, 1.0))
85
+ if mode == "noisy":
86
+ std = max(0.0, float(getattr(args, "pglobal_noise_std", 0.15)))
87
+ noise = torch.randn(P.shape, generator=generator, device=P.device, dtype=P.dtype) * std
88
+ return symmetrize_probability((P + noise).clamp(0.0, 1.0))
89
+ if mode == "topology":
90
+ topo_dist = _topological_distances(mol, int(P.shape[0]), P.device).to(dtype=P.dtype)
91
+ mapping_path = str(getattr(args, "pglobal_topology_mapping", "") or "")
92
+ if mapping_path:
93
+ with open(mapping_path, "r", encoding="utf-8") as handle:
94
+ payload = json.load(handle)
95
+ means = torch.as_tensor(payload["mean_q_by_bin"], device=P.device, dtype=P.dtype)
96
+ bins = torch.clamp(topo_dist.long(), min=1, max=int(means.numel())) - 1
97
+ topo = means[bins]
98
+ else:
99
+ scale = max(1e-3, float(getattr(args, "pglobal_topology_scale", 1.5)))
100
+ topo = torch.exp(-torch.clamp(topo_dist - 1.0, min=0.0) / scale)
101
+ # Legacy diagnostic fallback only; formal controls use a train-fit mapping.
102
+ if values.numel() > 1:
103
+ lo = torch.quantile(values, 0.05).to(dtype=P.dtype)
104
+ hi = torch.quantile(values, 0.95).to(dtype=P.dtype)
105
+ topo = lo + (hi - lo).clamp_min(1e-6) * topo
106
+ return symmetrize_probability(topo.clamp(0.0, 1.0))
107
+ raise ValueError(f"Unknown pglobal control mode: {mode}")
scripts/__init__.py ADDED
@@ -0,0 +1,2 @@
1
+ """Runtime helpers used by the public MANIMOL inference modules."""
2
+
@@ -0,0 +1,63 @@
1
+ #!/usr/bin/env python
2
+ """Quantify arbitrary basin-slot ordering across molecules."""
3
+
4
+ from __future__ import annotations
5
+
6
+ import argparse
7
+ import itertools
8
+ import json
9
+ import sys
10
+ from pathlib import Path
11
+
12
+ import torch
13
+
14
+ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
15
+ from geomanimol.data import load_molecule_groups
16
+ from geomanimol.geometry import DynamicGeometryMemory
17
+ from geomanimol.residual import etkdg_scaffold
18
+ from geomanimol.torsion_residual import torsion_defs, torsions_from_coords
19
+
20
+
21
+ def mode_signature(mol, labels, k, defs):
22
+ members = mol["conformations"][labels == k]
23
+ if not len(members):
24
+ members = mol["conformations"]
25
+ return torch.stack([torsions_from_coords(mol["mol"], c, defs) for c in members]).mean(0)
26
+
27
+
28
+ def main():
29
+ p = argparse.ArgumentParser()
30
+ p.add_argument("--data", default="data/geom_drugs_geomol_top20/geom_drugs_geomol_top20_debug_val.pt")
31
+ p.add_argument("--molecules", type=int, default=20)
32
+ p.add_argument("--output", default="outputs/geomanimol/basin_alignment_diagnostic.json")
33
+ args = p.parse_args()
34
+ molecules = load_molecule_groups(args.data, args.molecules)
35
+ memory = DynamicGeometryMemory(n_modes=3, manifold_dim=8); memory.initialize(molecules)
36
+ identity, matched, records = [], [], []
37
+ for i, left in enumerate(molecules):
38
+ defs_left = torsion_defs(left["mol"])
39
+ if not defs_left:
40
+ continue
41
+ left_labels = memory.get(left["mol_id"])["labels"]
42
+ for right in molecules[i + 1:]:
43
+ defs_right = torsion_defs(right["mol"])
44
+ if len(defs_left) != len(defs_right):
45
+ continue
46
+ right_labels = memory.get(right["mol_id"])["labels"]
47
+ a = torch.stack([mode_signature(left, left_labels, k, defs_left) for k in range(3)])
48
+ b = torch.stack([mode_signature(right, right_labels, k, defs_right) for k in range(3)])
49
+ cost = torch.zeros((3, 3))
50
+ for x in range(3):
51
+ for y in range(3):
52
+ delta = torch.atan2(torch.sin(a[x] - b[y]), torch.cos(a[x] - b[y]))
53
+ cost[x, y] = delta.abs().mean()
54
+ identity.append(float(cost.diag().mean()))
55
+ candidates = [float(cost[range(3), list(perm)].mean()) for perm in itertools.permutations(range(3))]
56
+ matched.append(min(candidates))
57
+ records.append({"left": left["mol_id"], "right": right["mol_id"], "identity_cost": identity[-1], "matched_cost": matched[-1]})
58
+ result = {"pairs": len(records), "mean_identity_cost_rad": sum(identity) / max(1, len(identity)), "mean_hungarian_cost_rad": sum(matched) / max(1, len(matched)), "records": records}
59
+ out = Path(args.output); out.parent.mkdir(parents=True, exist_ok=True); out.write_text(json.dumps(result, indent=2)); print(json.dumps({k:v for k,v in result.items() if k != 'records'}, indent=2)); print(f"Saved: {out}")
60
+
61
+
62
+ if __name__ == "__main__":
63
+ main()
@@ -0,0 +1,267 @@
1
+ #!/usr/bin/env python3
2
+ """Compare single-conformer and ensemble aggregation rules on HIF2A.
3
+
4
+ This is a downstream sensitivity diagnostic, not a virtual-screening claim.
5
+ All aggregation rules consume the same per-conformer receptor score table.
6
+ """
7
+
8
+ from __future__ import annotations
9
+
10
+ import argparse
11
+ import csv
12
+ import json
13
+ import math
14
+ from pathlib import Path
15
+
16
+ import numpy as np
17
+ from rdkit import Chem
18
+ from rdkit.Chem import AllChem
19
+
20
+
21
+ def parse_args():
22
+ parser = argparse.ArgumentParser()
23
+ parser.add_argument("--fixed_dump_name", action="store_true")
24
+ parser.add_argument("--data_root", default=None, help=argparse.SUPPRESS)
25
+ parser.add_argument("--scores_csv", required=True)
26
+ parser.add_argument("--experimental_csv", required=True)
27
+ parser.add_argument("--methods", default="etkdg,manimol")
28
+ parser.add_argument("--score_column", default="vina_score")
29
+ parser.add_argument("--random_repeats", type=int, default=200)
30
+ parser.add_argument("--temperature_k", type=float, default=298.15)
31
+ parser.add_argument("--softmin_tau", type=float, default=1.0)
32
+ parser.add_argument("--seed", type=int, default=20260820)
33
+ parser.add_argument("--output_prefix", required=True)
34
+ return parser.parse_args()
35
+
36
+
37
+ def read_csv(path):
38
+ with open(path, newline="") as handle:
39
+ return list(csv.DictReader(handle))
40
+
41
+
42
+ def number(value):
43
+ try:
44
+ result = float(value)
45
+ except Exception:
46
+ return None
47
+ return result if math.isfinite(result) else None
48
+
49
+
50
+ def ligand_id(value):
51
+ try:
52
+ value = float(value)
53
+ if value.is_integer():
54
+ return str(int(value))
55
+ except Exception:
56
+ pass
57
+ return str(value).strip()
58
+
59
+
60
+ def experimental_map(path):
61
+ result = {}
62
+ for row in read_csv(path):
63
+ key = row.get("Ligand") or row.get("Title") or row.get("ligand")
64
+ value = row.get("Exp. ΔG") or row.get("Exp. DG") or row.get("exp dg")
65
+ parsed = number(value)
66
+ if key is not None and parsed is not None:
67
+ result[ligand_id(key)] = parsed
68
+ return result
69
+
70
+
71
+ def rankdata(values):
72
+ order = np.argsort(values, kind="mergesort")
73
+ ranks = np.empty(len(values), dtype=float)
74
+ start = 0
75
+ while start < len(values):
76
+ end = start + 1
77
+ while end < len(values) and values[order[end]] == values[order[start]]:
78
+ end += 1
79
+ ranks[order[start:end]] = 0.5 * (start + end - 1) + 1
80
+ start = end
81
+ return ranks
82
+
83
+
84
+ def correlation(x, y):
85
+ if len(x) < 3 or np.std(x) == 0 or np.std(y) == 0:
86
+ return float("nan")
87
+ return float(np.corrcoef(x, y)[0, 1])
88
+
89
+
90
+ def loocv_affine_rmse(pred, exp):
91
+ fitted = []
92
+ for held_out in range(len(pred)):
93
+ keep = np.arange(len(pred)) != held_out
94
+ slope, intercept = np.polyfit(pred[keep], exp[keep], 1)
95
+ fitted.append(slope * pred[held_out] + intercept)
96
+ return float(np.sqrt(np.mean((np.asarray(fitted) - exp) ** 2)))
97
+
98
+
99
+ def pairwise_accuracy(pred, exp, minimum_delta=0.5):
100
+ correct = total = 0
101
+ for i in range(len(pred)):
102
+ for j in range(i + 1, len(pred)):
103
+ if abs(exp[i] - exp[j]) < minimum_delta or pred[i] == pred[j]:
104
+ continue
105
+ total += 1
106
+ correct += int((exp[i] - exp[j]) * (pred[i] - pred[j]) > 0)
107
+ return float(correct / total) if total else float("nan")
108
+
109
+
110
+ def topk_overlap(pred, exp, k=5):
111
+ k = min(k, len(pred))
112
+ return float(len(set(np.argsort(pred)[:k]) & set(np.argsort(exp)[:k])) / k)
113
+
114
+
115
+ def summarize(rows):
116
+ pred = np.asarray([row["pred_score"] for row in rows], dtype=float)
117
+ exp = np.asarray([row["exp_dg"] for row in rows], dtype=float)
118
+ return {
119
+ "n": len(rows),
120
+ "pearson": correlation(pred, exp),
121
+ "spearman": correlation(rankdata(pred), rankdata(exp)),
122
+ "loocv_affine_rmse": loocv_affine_rmse(pred, exp),
123
+ "pairwise_accuracy_delta0p5": pairwise_accuracy(pred, exp),
124
+ "top5_overlap": topk_overlap(pred, exp, 5),
125
+ }
126
+
127
+
128
+ def mmff_energies(path, cache):
129
+ if path in cache:
130
+ return cache[path]
131
+ energies = []
132
+ if not path or not Path(path).exists():
133
+ cache[path] = energies
134
+ return energies
135
+ for mol in Chem.SDMolSupplier(str(path), removeHs=False):
136
+ energy = float("nan")
137
+ if mol is not None:
138
+ try:
139
+ props = AllChem.MMFFGetMoleculeProperties(mol, mmffVariant="MMFF94s")
140
+ if props is not None:
141
+ ff = AllChem.MMFFGetMoleculeForceField(mol, props, confId=0)
142
+ if ff is not None:
143
+ energy = float(ff.CalcEnergy())
144
+ except Exception:
145
+ pass
146
+ energies.append(energy)
147
+ cache[path] = energies
148
+ return energies
149
+
150
+
151
+ def stable_softmin(scores, tau):
152
+ values = -np.asarray(scores, dtype=float) / tau
153
+ maximum = np.max(values)
154
+ return float(-tau * (maximum + np.log(np.mean(np.exp(values - maximum)))))
155
+
156
+
157
+ def aggregate(group, rule, rng, temperature, tau):
158
+ scores = np.asarray([row["score"] for row in group], dtype=float)
159
+ energies = np.asarray([row["energy"] for row in group], dtype=float)
160
+ if rule == "first_generated":
161
+ return float(scores[np.argmin([row["conf_id"] for row in group])])
162
+ if rule == "lowest_mmff_energy":
163
+ return float(scores[np.nanargmin(energies)]) if np.isfinite(energies).any() else float(scores[0])
164
+ if rule == "random_single":
165
+ return float(scores[rng.integers(0, len(scores))])
166
+ if rule == "ensemble_mean":
167
+ return float(scores.mean())
168
+ if rule == "ensemble_boltzmann":
169
+ if not np.isfinite(energies).any():
170
+ return float(scores.mean())
171
+ filled = energies.copy()
172
+ filled[~np.isfinite(filled)] = np.nanmax(filled[np.isfinite(filled)]) + 10.0
173
+ relative = filled - np.min(filled)
174
+ gas_constant = 0.0019872041 # kcal mol^-1 K^-1
175
+ weights = np.exp(-relative / (gas_constant * temperature))
176
+ weights /= weights.sum()
177
+ return float(np.sum(weights * scores))
178
+ if rule == "best_receptor_score":
179
+ return float(scores.min())
180
+ if rule == "ensemble_softmin":
181
+ return stable_softmin(scores, tau)
182
+ raise ValueError(rule)
183
+
184
+
185
+ def write_csv(path, rows):
186
+ path.parent.mkdir(parents=True, exist_ok=True)
187
+ if not rows:
188
+ path.write_text("")
189
+ return
190
+ with path.open("w", newline="") as handle:
191
+ writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
192
+ writer.writeheader()
193
+ writer.writerows(rows)
194
+
195
+
196
+ def main():
197
+ args = parse_args()
198
+ exp = experimental_map(args.experimental_csv)
199
+ methods = {value.strip() for value in args.methods.split(",") if value.strip()}
200
+ energy_cache = {}
201
+ grouped = {}
202
+ for row in read_csv(args.scores_csv):
203
+ method = row.get("method", "")
204
+ score = number(row.get(args.score_column))
205
+ ligand = ligand_id(row.get("ligand_name", ""))
206
+ if method not in methods or score is None or ligand not in exp:
207
+ continue
208
+ sdf_path = row.get("etkdg_sdf", "") if method == "etkdg" else row.get("manimol_sdf", "")
209
+ conf_id = int(float(row.get("conf_id", 0)))
210
+ energies = mmff_energies(sdf_path, energy_cache)
211
+ energy = energies[conf_id] if 0 <= conf_id < len(energies) else float("nan")
212
+ grouped.setdefault((method, row.get("complex_id", ""), ligand), []).append({
213
+ "score": score, "energy": energy, "conf_id": conf_id,
214
+ })
215
+
216
+ rules = [
217
+ "first_generated", "lowest_mmff_energy", "random_single",
218
+ "ensemble_mean", "ensemble_boltzmann", "ensemble_softmin", "best_receptor_score",
219
+ ]
220
+ per_ligand = []
221
+ replicate_summary = []
222
+ for method in sorted(methods):
223
+ for rule in rules:
224
+ repeats = args.random_repeats if rule == "random_single" else 1
225
+ for repeat in range(repeats):
226
+ rng = np.random.default_rng(args.seed + repeat)
227
+ rows = []
228
+ for (group_method, complex_id, ligand), group in grouped.items():
229
+ if group_method != method:
230
+ continue
231
+ pred = aggregate(group, rule, rng, args.temperature_k, args.softmin_tau)
232
+ row = {
233
+ "method": method, "aggregation": rule, "repeat": repeat,
234
+ "complex_id": complex_id, "ligand_id": ligand,
235
+ "pred_score": pred, "exp_dg": exp[ligand], "conformers": len(group),
236
+ }
237
+ rows.append(row)
238
+ per_ligand.append(row)
239
+ if len(rows) >= 3:
240
+ replicate_summary.append({
241
+ "method": method, "aggregation": rule, "repeat": repeat, **summarize(rows)
242
+ })
243
+
244
+ summary = []
245
+ for method in sorted(methods):
246
+ for rule in rules:
247
+ rows = [row for row in replicate_summary if row["method"] == method and row["aggregation"] == rule]
248
+ if not rows:
249
+ continue
250
+ result = {"method": method, "aggregation": rule, "repeats": len(rows), "n": rows[0]["n"]}
251
+ for key in ("pearson", "spearman", "loocv_affine_rmse", "pairwise_accuracy_delta0p5", "top5_overlap"):
252
+ values = np.asarray([row[key] for row in rows], dtype=float)
253
+ result[key + "_mean"] = float(np.nanmean(values))
254
+ result[key + "_std"] = float(np.nanstd(values, ddof=1)) if len(values) > 1 else 0.0
255
+ summary.append(result)
256
+
257
+ prefix = Path(args.output_prefix)
258
+ write_csv(prefix.with_name(prefix.name + "_per_ligand.csv"), per_ligand)
259
+ write_csv(prefix.with_name(prefix.name + "_replicates.csv"), replicate_summary)
260
+ write_csv(prefix.with_name(prefix.name + "_summary.csv"), summary)
261
+ prefix.with_name(prefix.name + "_summary.json").write_text(json.dumps(summary, indent=2) + "\n")
262
+ for row in summary:
263
+ print(row)
264
+
265
+
266
+ if __name__ == "__main__":
267
+ main()