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