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
torsion_manifold.py
ADDED
|
@@ -0,0 +1,281 @@
|
|
|
1
|
+
"""Graph-conditioned mixture model for the circular torsion state manifold.
|
|
2
|
+
|
|
3
|
+
The model deliberately represents conformer states in torsion space rather
|
|
4
|
+
than attempting to infer a single averaged atom-pair graph from a 2D graph.
|
|
5
|
+
Each mixture component is a circular prototype for the rotatable bonds of one
|
|
6
|
+
molecule; component weights form a graph-conditioned state prior.
|
|
7
|
+
"""
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
import math
|
|
11
|
+
|
|
12
|
+
import torch
|
|
13
|
+
import torch.nn as nn
|
|
14
|
+
import torch.nn.functional as F
|
|
15
|
+
|
|
16
|
+
from models.model0 import _torsion_rows
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
class TorsionStateMixturePrior(nn.Module):
|
|
20
|
+
"""Predict a mixture of periodic torsion-state prototypes from ``G``."""
|
|
21
|
+
|
|
22
|
+
def __init__(self, graph_dim: int, max_torsions: int, components: int, hidden_dim: int):
|
|
23
|
+
super().__init__()
|
|
24
|
+
self.graph_dim = int(graph_dim)
|
|
25
|
+
self.max_torsions = int(max_torsions)
|
|
26
|
+
self.components = int(components)
|
|
27
|
+
self.hidden_dim = int(hidden_dim)
|
|
28
|
+
self.trunk = nn.Sequential(
|
|
29
|
+
nn.Linear(self.graph_dim, self.hidden_dim),
|
|
30
|
+
nn.SiLU(),
|
|
31
|
+
nn.Linear(self.hidden_dim, self.hidden_dim),
|
|
32
|
+
nn.SiLU(),
|
|
33
|
+
)
|
|
34
|
+
self.weight_head = nn.Linear(self.hidden_dim, self.components)
|
|
35
|
+
self.prototype_head = nn.Linear(self.hidden_dim, self.components * self.max_torsions * 2)
|
|
36
|
+
|
|
37
|
+
def forward(self, graph_features: torch.Tensor):
|
|
38
|
+
squeeze = graph_features.dim() == 1
|
|
39
|
+
if squeeze:
|
|
40
|
+
graph_features = graph_features.unsqueeze(0)
|
|
41
|
+
hidden = self.trunk(graph_features)
|
|
42
|
+
logits = self.weight_head(hidden)
|
|
43
|
+
proto = self.prototype_head(hidden).view(-1, self.components, self.max_torsions, 2)
|
|
44
|
+
proto = proto / proto.norm(dim=-1, keepdim=True).clamp_min(1e-6)
|
|
45
|
+
return (logits[0], proto[0]) if squeeze else (logits, proto)
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
class TorsionModeCoveringPrior(TorsionStateMixturePrior):
|
|
49
|
+
"""A torsion mixture that represents a finite conformer ensemble.
|
|
50
|
+
|
|
51
|
+
Besides mode weights and circular prototypes, the model predicts a bounded
|
|
52
|
+
per-mode torsion spread. During training, prototype neighborhoods form a
|
|
53
|
+
differentiable finite set used by coverage--compactness losses. At
|
|
54
|
+
inference the spread is used only for budget allocation and local torsion
|
|
55
|
+
exploration; it never changes bond geometry directly.
|
|
56
|
+
"""
|
|
57
|
+
|
|
58
|
+
uses_budget_allocation = True
|
|
59
|
+
|
|
60
|
+
def __init__(self, graph_dim, max_torsions, components, hidden_dim, min_spread=0.04, max_spread=0.60):
|
|
61
|
+
super().__init__(graph_dim, max_torsions, components, hidden_dim)
|
|
62
|
+
self.min_spread = float(min_spread)
|
|
63
|
+
self.max_spread = float(max_spread)
|
|
64
|
+
self.spread_head = nn.Linear(self.hidden_dim, self.components * self.max_torsions)
|
|
65
|
+
|
|
66
|
+
def forward(self, graph_features):
|
|
67
|
+
squeeze = graph_features.dim() == 1
|
|
68
|
+
if squeeze:
|
|
69
|
+
graph_features = graph_features.unsqueeze(0)
|
|
70
|
+
hidden = self.trunk(graph_features)
|
|
71
|
+
logits = self.weight_head(hidden)
|
|
72
|
+
proto = self.prototype_head(hidden).view(-1, self.components, self.max_torsions, 2)
|
|
73
|
+
proto = proto / proto.norm(dim=-1, keepdim=True).clamp_min(1e-6)
|
|
74
|
+
spread = self.spread_head(hidden).view(-1, self.components, self.max_torsions)
|
|
75
|
+
spread = self.min_spread + (self.max_spread - self.min_spread) * torch.sigmoid(spread)
|
|
76
|
+
return (logits[0], proto[0], spread[0]) if squeeze else (logits, proto, spread)
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
def probability_graph_torsion_context(P, mol, torsion_index, max_torsions):
|
|
80
|
+
"""Summarize Stage-1 pair probabilities across each rotatable-bond cut.
|
|
81
|
+
|
|
82
|
+
For a torsion around bond ``i-j``, removing that bond partitions the
|
|
83
|
+
molecular graph into two fragments. The mean, spread, maximum, and upper
|
|
84
|
+
tail of ``P[A, B]`` form an interpretable probability-graph constraint for
|
|
85
|
+
that torsion: which two fragments are predicted to approach one another.
|
|
86
|
+
"""
|
|
87
|
+
context = torch.zeros(int(max_torsions), 4, dtype=P.dtype, device=P.device)
|
|
88
|
+
valid = torch.zeros(int(max_torsions), dtype=torch.bool, device=P.device)
|
|
89
|
+
rows = _torsion_rows(torsion_index)
|
|
90
|
+
if P is None or mol is None or rows is None or rows.numel() == 0:
|
|
91
|
+
return context, valid
|
|
92
|
+
|
|
93
|
+
n_atoms = min(int(P.size(0)), int(mol.GetNumAtoms()))
|
|
94
|
+
adjacency = [[] for _ in range(n_atoms)]
|
|
95
|
+
for bond in mol.GetBonds():
|
|
96
|
+
left, right = int(bond.GetBeginAtomIdx()), int(bond.GetEndAtomIdx())
|
|
97
|
+
if left < n_atoms and right < n_atoms:
|
|
98
|
+
adjacency[left].append(right)
|
|
99
|
+
adjacency[right].append(left)
|
|
100
|
+
|
|
101
|
+
for index, row in enumerate(rows[: int(max_torsions)]):
|
|
102
|
+
if row.numel() < 4:
|
|
103
|
+
continue
|
|
104
|
+
left, right = int(row[1]), int(row[2])
|
|
105
|
+
if min(left, right) < 0 or max(left, right) >= n_atoms:
|
|
106
|
+
continue
|
|
107
|
+
stack, seen = [left], {left}
|
|
108
|
+
while stack:
|
|
109
|
+
current = stack.pop()
|
|
110
|
+
for neighbor in adjacency[current]:
|
|
111
|
+
if {current, neighbor} == {left, right} or neighbor in seen:
|
|
112
|
+
continue
|
|
113
|
+
seen.add(neighbor)
|
|
114
|
+
stack.append(neighbor)
|
|
115
|
+
other = [atom for atom in range(n_atoms) if atom not in seen]
|
|
116
|
+
if not seen or not other:
|
|
117
|
+
continue
|
|
118
|
+
a = torch.tensor(sorted(seen), dtype=torch.long, device=P.device)
|
|
119
|
+
b = torch.tensor(other, dtype=torch.long, device=P.device)
|
|
120
|
+
values = P[a][:, b].reshape(-1)
|
|
121
|
+
values = values[torch.isfinite(values)]
|
|
122
|
+
if values.numel() == 0:
|
|
123
|
+
continue
|
|
124
|
+
context[index, 0] = values.mean()
|
|
125
|
+
context[index, 1] = values.std(unbiased=False)
|
|
126
|
+
context[index, 2] = values.max()
|
|
127
|
+
context[index, 3] = torch.quantile(values, 0.90)
|
|
128
|
+
valid[index] = True
|
|
129
|
+
return context, valid
|
|
130
|
+
|
|
131
|
+
|
|
132
|
+
def probability_graph_torsion_pair_bias(P, torsion_index, max_torsions):
|
|
133
|
+
"""Build a torsion--torsion interaction bias directly from atom-pair P.
|
|
134
|
+
|
|
135
|
+
Each rotatable bond is represented by its center bond atoms ``(b, c)`` from
|
|
136
|
+
a torsion row ``a-b-c-d``. The bias between two torsions is the average
|
|
137
|
+
probability among their center atoms. This makes the mode-specific
|
|
138
|
+
probability graph alter the torsion-flow message passing itself instead of
|
|
139
|
+
only contributing a pooled global condition.
|
|
140
|
+
"""
|
|
141
|
+
size = int(max_torsions)
|
|
142
|
+
bias = torch.zeros(size, size, dtype=P.dtype, device=P.device)
|
|
143
|
+
valid = torch.zeros(size, dtype=torch.bool, device=P.device)
|
|
144
|
+
rows = _torsion_rows(torsion_index)
|
|
145
|
+
if P is None or rows is None or rows.numel() == 0:
|
|
146
|
+
return bias, valid
|
|
147
|
+
n_atoms = int(P.size(0))
|
|
148
|
+
centers = []
|
|
149
|
+
for row in rows[:size]:
|
|
150
|
+
if row.numel() < 4:
|
|
151
|
+
centers.append(None)
|
|
152
|
+
continue
|
|
153
|
+
left, right = int(row[1]), int(row[2])
|
|
154
|
+
if min(left, right) < 0 or max(left, right) >= n_atoms:
|
|
155
|
+
centers.append(None)
|
|
156
|
+
continue
|
|
157
|
+
centers.append((left, right))
|
|
158
|
+
for i, ci in enumerate(centers):
|
|
159
|
+
if ci is None:
|
|
160
|
+
continue
|
|
161
|
+
valid[i] = True
|
|
162
|
+
ai = torch.tensor(ci, dtype=torch.long, device=P.device)
|
|
163
|
+
for j, cj in enumerate(centers):
|
|
164
|
+
if cj is None or i == j:
|
|
165
|
+
continue
|
|
166
|
+
aj = torch.tensor(cj, dtype=torch.long, device=P.device)
|
|
167
|
+
values = P[ai][:, aj].reshape(-1)
|
|
168
|
+
values = values[torch.isfinite(values)]
|
|
169
|
+
if values.numel() > 0:
|
|
170
|
+
bias[i, j] = values.mean()
|
|
171
|
+
if valid.any():
|
|
172
|
+
block = bias[valid][:, valid]
|
|
173
|
+
if block.numel() > 0:
|
|
174
|
+
mean = block.mean()
|
|
175
|
+
std = block.std(unbiased=False).clamp_min(1e-6)
|
|
176
|
+
bias = (bias - mean) / std
|
|
177
|
+
bias.fill_diagonal_(0.0)
|
|
178
|
+
return bias, valid
|
|
179
|
+
|
|
180
|
+
|
|
181
|
+
class ProbabilityAlignedTorsionStateMixturePrior(nn.Module):
|
|
182
|
+
"""Torsion-state mixture whose prototypes are modulated by Stage-1 ``P``.
|
|
183
|
+
|
|
184
|
+
The model remains compact: ``P`` is not decoded into coordinates. Instead,
|
|
185
|
+
its cross-fragment summaries condition the circular torsion prototypes.
|
|
186
|
+
This creates a direct, inspectable ``P -> torsion-state`` bridge.
|
|
187
|
+
"""
|
|
188
|
+
|
|
189
|
+
uses_p_context = True
|
|
190
|
+
|
|
191
|
+
def __init__(self, graph_dim, max_torsions, components, hidden_dim, context_dim=4):
|
|
192
|
+
super().__init__()
|
|
193
|
+
self.graph_dim = int(graph_dim)
|
|
194
|
+
self.max_torsions = int(max_torsions)
|
|
195
|
+
self.components = int(components)
|
|
196
|
+
self.hidden_dim = int(hidden_dim)
|
|
197
|
+
self.context_dim = int(context_dim)
|
|
198
|
+
self.graph_trunk = nn.Sequential(
|
|
199
|
+
nn.Linear(self.graph_dim, self.hidden_dim),
|
|
200
|
+
nn.SiLU(),
|
|
201
|
+
nn.Linear(self.hidden_dim, self.hidden_dim),
|
|
202
|
+
nn.SiLU(),
|
|
203
|
+
)
|
|
204
|
+
self.context_trunk = nn.Sequential(
|
|
205
|
+
nn.Linear(self.context_dim, self.hidden_dim),
|
|
206
|
+
nn.SiLU(),
|
|
207
|
+
nn.Linear(self.hidden_dim, self.hidden_dim),
|
|
208
|
+
nn.SiLU(),
|
|
209
|
+
)
|
|
210
|
+
self.weight_head = nn.Linear(self.hidden_dim * 2, self.components)
|
|
211
|
+
self.prototype_head = nn.Linear(self.hidden_dim * 2, self.components * 2)
|
|
212
|
+
|
|
213
|
+
def forward(self, graph_features, torsion_context, valid_mask=None):
|
|
214
|
+
squeeze = graph_features.dim() == 1
|
|
215
|
+
if squeeze:
|
|
216
|
+
graph_features = graph_features.unsqueeze(0)
|
|
217
|
+
if torsion_context.dim() == 2:
|
|
218
|
+
torsion_context = torsion_context.unsqueeze(0)
|
|
219
|
+
if valid_mask is None:
|
|
220
|
+
valid_mask = torch.ones(
|
|
221
|
+
torsion_context.shape[:2], dtype=torch.bool, device=torsion_context.device
|
|
222
|
+
)
|
|
223
|
+
elif valid_mask.dim() == 1:
|
|
224
|
+
valid_mask = valid_mask.unsqueeze(0)
|
|
225
|
+
if valid_mask.shape != torsion_context.shape[:2]:
|
|
226
|
+
raise ValueError("valid_mask must match the first two torsion_context dimensions")
|
|
227
|
+
graph_hidden = self.graph_trunk(graph_features)
|
|
228
|
+
context_hidden = self.context_trunk(torsion_context)
|
|
229
|
+
weights = valid_mask.to(dtype=context_hidden.dtype).unsqueeze(-1)
|
|
230
|
+
pooled_context = (context_hidden * weights).sum(dim=1) / weights.sum(dim=1).clamp_min(1.0)
|
|
231
|
+
logits = self.weight_head(torch.cat([graph_hidden, pooled_context], dim=-1))
|
|
232
|
+
graph_expand = graph_hidden[:, None, :].expand(-1, context_hidden.size(1), -1)
|
|
233
|
+
pair_hidden = torch.cat([graph_expand, context_hidden], dim=-1)
|
|
234
|
+
proto = self.prototype_head(pair_hidden)
|
|
235
|
+
proto = proto.view(-1, self.max_torsions, self.components, 2).permute(0, 2, 1, 3)
|
|
236
|
+
proto = proto / proto.norm(dim=-1, keepdim=True).clamp_min(1e-6)
|
|
237
|
+
return (logits[0], proto[0]) if squeeze else (logits, proto)
|
|
238
|
+
|
|
239
|
+
|
|
240
|
+
def circular_torsion_distance(
|
|
241
|
+
prototypes: torch.Tensor,
|
|
242
|
+
targets: torch.Tensor,
|
|
243
|
+
valid_mask: torch.Tensor,
|
|
244
|
+
) -> torch.Tensor:
|
|
245
|
+
"""Return mean ``1-cos`` distances with shape ``[targets, components]``."""
|
|
246
|
+
if targets.dim() == 2:
|
|
247
|
+
targets = targets.unsqueeze(0)
|
|
248
|
+
mask = valid_mask.to(dtype=prototypes.dtype).view(1, 1, -1)
|
|
249
|
+
similarity = (targets[:, None] * prototypes[None]).sum(dim=-1)
|
|
250
|
+
distance = (1.0 - similarity) * mask
|
|
251
|
+
return distance.sum(dim=-1) / mask.sum(dim=-1).clamp_min(1.0)
|
|
252
|
+
|
|
253
|
+
|
|
254
|
+
def mixture_torsion_nll(
|
|
255
|
+
logits: torch.Tensor,
|
|
256
|
+
prototypes: torch.Tensor,
|
|
257
|
+
targets: torch.Tensor,
|
|
258
|
+
valid_mask: torch.Tensor,
|
|
259
|
+
concentration: float,
|
|
260
|
+
) -> tuple[torch.Tensor, torch.Tensor]:
|
|
261
|
+
"""Negative log likelihood under a soft circular prototype mixture."""
|
|
262
|
+
distance = circular_torsion_distance(prototypes, targets, valid_mask)
|
|
263
|
+
log_prob = F.log_softmax(logits, dim=-1).view(1, -1) - float(concentration) * distance
|
|
264
|
+
return -torch.logsumexp(log_prob, dim=-1).mean(), distance
|
|
265
|
+
|
|
266
|
+
|
|
267
|
+
def prior_scores_for_signatures(
|
|
268
|
+
logits: torch.Tensor,
|
|
269
|
+
prototypes: torch.Tensor,
|
|
270
|
+
signatures: torch.Tensor,
|
|
271
|
+
) -> torch.Tensor:
|
|
272
|
+
"""Reference-free low-is-better state-manifold scores for candidates."""
|
|
273
|
+
torsions = int(signatures.size(1) // 2)
|
|
274
|
+
if torsions <= 0:
|
|
275
|
+
return torch.zeros(signatures.size(0), device=signatures.device)
|
|
276
|
+
# ``torsion_signature_matrix`` stores all sin values followed by all cos
|
|
277
|
+
# values, rather than interleaving them per torsion.
|
|
278
|
+
vectors = torch.stack([signatures[:, :torsions], signatures[:, torsions : 2 * torsions]], dim=-1)
|
|
279
|
+
mask = torch.ones(torsions, dtype=torch.bool, device=signatures.device)
|
|
280
|
+
distance = circular_torsion_distance(prototypes[:, :torsions], vectors, mask)
|
|
281
|
+
return -torch.logsumexp(F.log_softmax(logits, dim=-1).view(1, -1) - distance, dim=-1)
|
train.py
ADDED
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
"""MANIMOL training entry point.
|
|
3
|
+
|
|
4
|
+
The current MANIMOL pipeline is trained in stages:
|
|
5
|
+
|
|
6
|
+
1. stage1 : probability-graph encoder
|
|
7
|
+
2. torsion : base torsion generator
|
|
8
|
+
3. pbasin : probability-basin torsion generator
|
|
9
|
+
4. denoiser : noise-conditioned torsion denoiser
|
|
10
|
+
5. precision : precision post-denoiser / local corrector
|
|
11
|
+
|
|
12
|
+
Examples
|
|
13
|
+
--------
|
|
14
|
+
python train.py --stage stage1 ...
|
|
15
|
+
python train.py --stage pbasin ...
|
|
16
|
+
python train.py denoiser ...
|
|
17
|
+
|
|
18
|
+
The numbered training scripts are kept as implementation modules for backward
|
|
19
|
+
compatibility, but this file is the public training interface.
|
|
20
|
+
"""
|
|
21
|
+
from __future__ import annotations
|
|
22
|
+
|
|
23
|
+
import runpy
|
|
24
|
+
import sys
|
|
25
|
+
from pathlib import Path
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
ROOT = Path(__file__).resolve().parent
|
|
29
|
+
|
|
30
|
+
STAGE_TO_SCRIPT = {
|
|
31
|
+
"stage1": "train_graph_encoder.py",
|
|
32
|
+
"torsion": "train_torsion_generator.py",
|
|
33
|
+
"pbasin": "train_probability_basin.py",
|
|
34
|
+
"denoiser": "train_torsional_denoiser.py",
|
|
35
|
+
"precision": "train_local_torsion_corrector.py",
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def _extract_stage(argv: list[str]) -> tuple[str, list[str]]:
|
|
40
|
+
if len(argv) > 1 and argv[1] in STAGE_TO_SCRIPT:
|
|
41
|
+
return argv[1], [argv[0]] + argv[2:]
|
|
42
|
+
|
|
43
|
+
stage = "stage1"
|
|
44
|
+
cleaned = [argv[0]]
|
|
45
|
+
i = 1
|
|
46
|
+
while i < len(argv):
|
|
47
|
+
item = argv[i]
|
|
48
|
+
if item == "--stage":
|
|
49
|
+
if i + 1 >= len(argv):
|
|
50
|
+
raise SystemExit("--stage requires one of: " + ", ".join(STAGE_TO_SCRIPT))
|
|
51
|
+
stage = argv[i + 1]
|
|
52
|
+
i += 2
|
|
53
|
+
continue
|
|
54
|
+
if item.startswith("--stage="):
|
|
55
|
+
stage = item.split("=", 1)[1]
|
|
56
|
+
i += 1
|
|
57
|
+
continue
|
|
58
|
+
cleaned.append(item)
|
|
59
|
+
i += 1
|
|
60
|
+
return stage, cleaned
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
def main() -> None:
|
|
64
|
+
stage, forwarded = _extract_stage(sys.argv)
|
|
65
|
+
if stage not in STAGE_TO_SCRIPT:
|
|
66
|
+
choices = ", ".join(STAGE_TO_SCRIPT)
|
|
67
|
+
raise SystemExit(f"Unknown MANIMOL training stage '{stage}'. Choose from: {choices}")
|
|
68
|
+
|
|
69
|
+
script = ROOT / STAGE_TO_SCRIPT[stage]
|
|
70
|
+
if not script.exists():
|
|
71
|
+
raise SystemExit(f"Training script for stage '{stage}' was not found: {script}")
|
|
72
|
+
|
|
73
|
+
sys.argv = [str(script)] + forwarded[1:]
|
|
74
|
+
runpy.run_path(str(script), run_name="__main__")
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
if __name__ == "__main__":
|
|
78
|
+
main()
|
train_graph_encoder.py
ADDED
|
@@ -0,0 +1,206 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
# train.py
|
|
3
|
+
# Probability-guided manifold conformer generation
|
|
4
|
+
|
|
5
|
+
import os
|
|
6
|
+
import warnings
|
|
7
|
+
import logging
|
|
8
|
+
import torch
|
|
9
|
+
|
|
10
|
+
try:
|
|
11
|
+
from torch.utils.tensorboard import SummaryWriter
|
|
12
|
+
except ModuleNotFoundError:
|
|
13
|
+
class SummaryWriter: # type: ignore[no-redef]
|
|
14
|
+
"""No-op fallback for inference environments without tensorboard."""
|
|
15
|
+
|
|
16
|
+
def __init__(self, *args, **kwargs):
|
|
17
|
+
pass
|
|
18
|
+
|
|
19
|
+
def add_scalar(self, *args, **kwargs):
|
|
20
|
+
pass
|
|
21
|
+
|
|
22
|
+
def add_histogram(self, *args, **kwargs):
|
|
23
|
+
pass
|
|
24
|
+
|
|
25
|
+
def flush(self):
|
|
26
|
+
pass
|
|
27
|
+
|
|
28
|
+
def close(self):
|
|
29
|
+
pass
|
|
30
|
+
|
|
31
|
+
from args_parse import args_parser
|
|
32
|
+
from exputils import initialize_exp, set_seed, get_dump_path, merge_args_from_paths
|
|
33
|
+
from trainer import Trainer
|
|
34
|
+
from utils.helpers import get_arg
|
|
35
|
+
|
|
36
|
+
warnings.filterwarnings("ignore", category=DeprecationWarning)
|
|
37
|
+
|
|
38
|
+
from rdkit import RDLogger
|
|
39
|
+
RDLogger.DisableLog("rdApp.*")
|
|
40
|
+
|
|
41
|
+
logging.basicConfig(
|
|
42
|
+
level=logging.INFO,
|
|
43
|
+
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
|
|
44
|
+
)
|
|
45
|
+
|
|
46
|
+
logger = logging.getLogger(__name__)
|
|
47
|
+
|
|
48
|
+
|
|
49
|
+
def fix_args(args):
|
|
50
|
+
args.train_model = "teacher"
|
|
51
|
+
args.model_type = "GNNEncoder"
|
|
52
|
+
args.early_stop = getattr(args, "early_stop", True)
|
|
53
|
+
|
|
54
|
+
train_stage = getattr(args, "train_stage", "gnn")
|
|
55
|
+
|
|
56
|
+
if train_stage not in ["gnn", "multimode"]:
|
|
57
|
+
raise ValueError(f"Unknown train_stage={train_stage}")
|
|
58
|
+
|
|
59
|
+
args.train_stage = train_stage
|
|
60
|
+
|
|
61
|
+
metric = getattr(args, "metric", None)
|
|
62
|
+
if metric is None:
|
|
63
|
+
metric = "CE" if train_stage == "gnn" else "RMSD"
|
|
64
|
+
args.metric = metric
|
|
65
|
+
|
|
66
|
+
args.use_pos_loss = True
|
|
67
|
+
|
|
68
|
+
cuda_available = torch.cuda.is_available()
|
|
69
|
+
if getattr(args, "auto_device_config", True):
|
|
70
|
+
# Keep manually specified --bs, but upgrade the parser default when CUDA is available.
|
|
71
|
+
current_bs = int(getattr(args, "bs", 32))
|
|
72
|
+
if current_bs == 32:
|
|
73
|
+
args.bs = int(getattr(args, "cuda_bs", 96) if cuda_available else getattr(args, "cpu_bs", 32))
|
|
74
|
+
if getattr(args, "num_workers", None) is None:
|
|
75
|
+
args.num_workers = int(
|
|
76
|
+
getattr(args, "cuda_num_workers", 0) if cuda_available else getattr(args, "cpu_num_workers", 0)
|
|
77
|
+
)
|
|
78
|
+
if getattr(args, "prefetch_factor", None) is None:
|
|
79
|
+
args.prefetch_factor = int(getattr(args, "cuda_prefetch_factor", 2)) if cuda_available else None
|
|
80
|
+
if getattr(args, "pin_memory", None) is None:
|
|
81
|
+
args.pin_memory = bool(cuda_available)
|
|
82
|
+
if cuda_available:
|
|
83
|
+
torch.backends.cudnn.benchmark = True
|
|
84
|
+
else:
|
|
85
|
+
if getattr(args, "num_workers", None) is None:
|
|
86
|
+
args.num_workers = 0
|
|
87
|
+
if getattr(args, "prefetch_factor", None) is None:
|
|
88
|
+
args.prefetch_factor = None
|
|
89
|
+
if getattr(args, "pin_memory", None) is None:
|
|
90
|
+
args.pin_memory = False
|
|
91
|
+
|
|
92
|
+
args.max_confs = int(getattr(args, "max_confs", 5))
|
|
93
|
+
args.num_modes = int(getattr(args, "num_modes", 10))
|
|
94
|
+
|
|
95
|
+
mode_dim = getattr(args, "mode_dim", None)
|
|
96
|
+
latent_dim = getattr(args, "latent_dim", None)
|
|
97
|
+
|
|
98
|
+
if mode_dim is None and latent_dim is None:
|
|
99
|
+
mode_dim = 32
|
|
100
|
+
elif mode_dim is None:
|
|
101
|
+
mode_dim = latent_dim
|
|
102
|
+
elif latent_dim is not None:
|
|
103
|
+
mode_dim = latent_dim
|
|
104
|
+
|
|
105
|
+
args.mode_dim = int(mode_dim)
|
|
106
|
+
args.latent_dim = int(mode_dim)
|
|
107
|
+
|
|
108
|
+
# refinement steps 兼容命名
|
|
109
|
+
args.num_refine_steps = int(
|
|
110
|
+
getattr(args, "num_refine_steps", getattr(args, "refine_steps", 4))
|
|
111
|
+
)
|
|
112
|
+
args.refine_steps = args.num_refine_steps
|
|
113
|
+
|
|
114
|
+
# GNN feature dims
|
|
115
|
+
args.node_dim = int(getattr(args, "node_dim", 39))
|
|
116
|
+
args.edge_dim = int(getattr(args, "edge_dim", 13))
|
|
117
|
+
|
|
118
|
+
# Stage 1
|
|
119
|
+
args.lambda_global = float(getattr(args, "lambda_global", 1.0))
|
|
120
|
+
args.lambda_ab = float(getattr(args, "lambda_ab", 1e-4))
|
|
121
|
+
|
|
122
|
+
# Stage 2
|
|
123
|
+
args.lambda_coarse_rmsd = float(getattr(args, "lambda_coarse_rmsd", 1.0))
|
|
124
|
+
args.lambda_refine_rmsd = float(
|
|
125
|
+
getattr(args, "lambda_refine_rmsd", getattr(args, "lambda_rmsd", 1.0))
|
|
126
|
+
)
|
|
127
|
+
args.lambda_ce_manifold = float(getattr(args, "lambda_ce_manifold", 0.1))
|
|
128
|
+
|
|
129
|
+
# compatibility
|
|
130
|
+
args.lambda_rmsd = float(getattr(args, "lambda_rmsd", args.lambda_refine_rmsd))
|
|
131
|
+
args.eval_num_samples = int(getattr(args, "eval_num_samples", 100))
|
|
132
|
+
args.pos_w = args.lambda_refine_rmsd
|
|
133
|
+
args.inv_alpha = 0.0
|
|
134
|
+
|
|
135
|
+
return args
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
def build_writer(logger_path):
|
|
139
|
+
tb_dir = os.path.join(logger_path, "tensorboard")
|
|
140
|
+
os.makedirs(tb_dir, exist_ok=True)
|
|
141
|
+
return SummaryWriter(log_dir=tb_dir)
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
def main(args=None, optuna_trial=None):
|
|
145
|
+
if args is None:
|
|
146
|
+
args = args_parser()
|
|
147
|
+
|
|
148
|
+
args = fix_args(args)
|
|
149
|
+
|
|
150
|
+
try:
|
|
151
|
+
args = merge_args_from_paths(args, attr_name="paras_path")
|
|
152
|
+
except Exception:
|
|
153
|
+
logger.exception("merge_args_from_paths failed, continue with raw args.")
|
|
154
|
+
|
|
155
|
+
args = fix_args(args)
|
|
156
|
+
|
|
157
|
+
if get_arg(args, "run_bayesian_optimization", False):
|
|
158
|
+
logger.info("Bayesian optimization requested. Use dedicated BO pipeline.")
|
|
159
|
+
return None
|
|
160
|
+
|
|
161
|
+
initialize_exp(args)
|
|
162
|
+
set_seed(getattr(args, "random_seed", 0))
|
|
163
|
+
|
|
164
|
+
logger_path = get_dump_path(args)
|
|
165
|
+
writer = build_writer(logger_path)
|
|
166
|
+
|
|
167
|
+
logger.info("=" * 60)
|
|
168
|
+
logger.info("Probability-guided manifold conformer generation")
|
|
169
|
+
logger.info(f"train_stage = {args.train_stage}")
|
|
170
|
+
logger.info(f"metric = {args.metric}")
|
|
171
|
+
logger.info(f"num_modes = {args.num_modes}")
|
|
172
|
+
logger.info(f"mode_dim = {args.mode_dim}")
|
|
173
|
+
logger.info(f"num_refine_steps = {args.num_refine_steps}")
|
|
174
|
+
logger.info(f"cuda_available = {torch.cuda.is_available()}")
|
|
175
|
+
logger.info(f"batch_size = {args.bs}")
|
|
176
|
+
logger.info(f"num_workers = {args.num_workers}")
|
|
177
|
+
logger.info(f"prefetch_factor = {args.prefetch_factor}")
|
|
178
|
+
logger.info(f"pin_memory = {args.pin_memory}")
|
|
179
|
+
logger.info("=" * 60)
|
|
180
|
+
|
|
181
|
+
trainer = Trainer(
|
|
182
|
+
args=args,
|
|
183
|
+
writer=writer,
|
|
184
|
+
logger_path=logger_path,
|
|
185
|
+
)
|
|
186
|
+
|
|
187
|
+
try:
|
|
188
|
+
result = trainer.run(optuna_trial=optuna_trial)
|
|
189
|
+
|
|
190
|
+
logger.info("Training finished.")
|
|
191
|
+
logger.info(
|
|
192
|
+
"Best checkpoint expected under: %s",
|
|
193
|
+
os.path.join(logger_path, "checkpoints", "best_model.pth"),
|
|
194
|
+
)
|
|
195
|
+
|
|
196
|
+
return result
|
|
197
|
+
|
|
198
|
+
finally:
|
|
199
|
+
try:
|
|
200
|
+
writer.close()
|
|
201
|
+
except Exception:
|
|
202
|
+
pass
|
|
203
|
+
|
|
204
|
+
|
|
205
|
+
if __name__ == "__main__":
|
|
206
|
+
main()
|