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