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
@@ -0,0 +1,1021 @@
1
+ #!/usr/bin/env python3
2
+ """Inference for train_torsional_denoiser.py noise-conditioned torsion denoiser."""
3
+
4
+ from __future__ import annotations
5
+
6
+ import sys
7
+ from argparse import ArgumentParser
8
+
9
+ import torch
10
+
11
+ import infer_base_conformers
12
+ import infer_torsion
13
+ from pgraph_controls import controlled_pglobal
14
+ from models.model0 import GNNEncoder, _torsion_rows, apply_torsion_residuals, torsion_angles
15
+ from train_torsional_denoiser import NoiseTorsionDenoiser, load_base_model, noised_conformer
16
+
17
+
18
+ class DenoiseWrapper:
19
+ def __init__(self, base_model, denoiser, post_denoiser=None, pbasin_model=None, torsion_manifold_prior=None):
20
+ self.base_model = base_model
21
+ self.denoiser = denoiser
22
+ self.post_denoiser = post_denoiser
23
+ self.pbasin_model = pbasin_model
24
+ self.torsion_manifold_prior = torsion_manifold_prior
25
+ self.num_modes = 10
26
+
27
+
28
+ def parse_denoise_args():
29
+ parser = ArgumentParser(add_help=False)
30
+ parser.add_argument("--base_checkpoint", type=str, required=True)
31
+ parser.add_argument("--denoiser_checkpoint", type=str, required=True)
32
+ parser.add_argument("--denoise_steps", type=int, default=10)
33
+ parser.add_argument("--denoise_sigma_max", type=float, default=0.75)
34
+ parser.add_argument("--denoise_sigma_min", type=float, default=0.05)
35
+ parser.add_argument("--denoise_step_scale", type=float, default=1.0)
36
+ parser.add_argument("--denoise_initial_noise", type=float, default=0.75)
37
+ parser.add_argument(
38
+ "--pbasin_only",
39
+ action="store_true",
40
+ help="Generate every learned candidate with the Stage-II/P-basin branch, disabling denoiser sampling.",
41
+ )
42
+ parser.add_argument(
43
+ "--denoise_polish_steps",
44
+ type=int,
45
+ default=0,
46
+ help="Extra low-noise denoising steps after the normal schedule.",
47
+ )
48
+ parser.add_argument("--denoise_polish_sigma", type=float, default=0.03)
49
+ parser.add_argument("--denoise_polish_step_scale", type=float, default=0.35)
50
+ parser.add_argument(
51
+ "--denoise_precision_fraction",
52
+ type=float,
53
+ default=0.0,
54
+ help=(
55
+ "Fraction of candidates sampled with a lower-noise precision schedule. "
56
+ "This keeps the candidate budget unchanged while mixing coverage and accuracy hypotheses."
57
+ ),
58
+ )
59
+ parser.add_argument("--denoise_precision_steps", type=int, default=0)
60
+ parser.add_argument("--denoise_precision_sigma_max", type=float, default=0.45)
61
+ parser.add_argument("--denoise_precision_sigma_min", type=float, default=0.02)
62
+ parser.add_argument("--denoise_precision_step_scale", type=float, default=0.65)
63
+ parser.add_argument("--denoise_precision_initial_noise", type=float, default=0.45)
64
+ parser.add_argument(
65
+ "--post_denoiser_checkpoint",
66
+ type=str,
67
+ default="",
68
+ help="Optional candidate-level denoiser used only as a post-generation local corrector.",
69
+ )
70
+ parser.add_argument("--post_denoise_steps", type=int, default=0)
71
+ parser.add_argument("--post_denoise_sigma", type=float, default=0.02)
72
+ parser.add_argument("--post_denoise_step_scale", type=float, default=0.35)
73
+ parser.add_argument(
74
+ "--final_snap_steps",
75
+ type=int,
76
+ default=0,
77
+ help="Add low-noise torsion-snap variants to the generated candidate pool before final selection.",
78
+ )
79
+ parser.add_argument("--final_snap_sigma", type=float, default=0.012)
80
+ parser.add_argument("--final_snap_step_scale", type=float, default=0.18)
81
+ parser.add_argument("--final_snap_max_candidates", type=int, default=0)
82
+ parser.add_argument("--final_snap_use_post_denoiser", action="store_true")
83
+ parser.add_argument("--final_snap_keep_original", action="store_true")
84
+ parser.add_argument("--torsion_mode_max", type=int, default=64)
85
+ parser.add_argument(
86
+ "--torsion_manifold_prior_path",
87
+ type=str,
88
+ default="",
89
+ help="Optional graph-conditioned torsion-mixture prior used for proposal and/or compact-set selection.",
90
+ )
91
+ parser.add_argument(
92
+ "--torsion_manifold_proposal_fraction",
93
+ type=float,
94
+ default=0.0,
95
+ help="Fraction of the denoise branch initialized from torsion-manifold mixture prototypes.",
96
+ )
97
+ parser.add_argument(
98
+ "--torsion_manifold_proposal_strength",
99
+ type=float,
100
+ default=0.55,
101
+ help="Circular interpolation strength from an ETKDG seed toward a mixture torsion prototype.",
102
+ )
103
+ parser.add_argument(
104
+ "--torsion_manifold_proposal_noise",
105
+ type=float,
106
+ default=0.18,
107
+ help="Per-torsion Gaussian perturbation (radians) around a mixture prototype.",
108
+ )
109
+ parser.add_argument(
110
+ "--torsion_manifold_proposal_denoise_noise_scale",
111
+ type=float,
112
+ default=0.50,
113
+ help="Multiplier for initial torsion noise on mixture-initialized candidates.",
114
+ )
115
+ parser.add_argument(
116
+ "--torsion_manifold_p_context_control",
117
+ type=str,
118
+ default="normal",
119
+ choices=["normal", "zero", "shuffle"],
120
+ help="Control only the Stage-1 P-to-torsion bridge; it does not alter denoiser conditioning.",
121
+ )
122
+ parser.add_argument(
123
+ "--manifold_use_mode_p",
124
+ action="store_true",
125
+ help="Use the P-basin checkpoint's learned mode-specific probability graph during torsion decoding.",
126
+ )
127
+ parser.add_argument("--torsion_base_method", type=str, default="etkdg", choices=["etkdg", "rdkit_dg", "random3d"])
128
+ parser.add_argument("--torsion_base_confs", type=int, default=0)
129
+ parser.add_argument(
130
+ "--pbasin_checkpoint",
131
+ type=str,
132
+ default="",
133
+ help="Optional P-basin Stage-2 checkpoint mixed into the denoise candidate pool.",
134
+ )
135
+ parser.add_argument(
136
+ "--pbasin_fraction",
137
+ type=float,
138
+ default=0.0,
139
+ help="Fraction of the model candidate budget allocated to P-basin torsion candidates.",
140
+ )
141
+ parser.add_argument(
142
+ "--pbudget_adaptive",
143
+ action="store_true",
144
+ help=(
145
+ "Let the Stage-1 probability graph decide the denoise/P-basin candidate split. "
146
+ "This is useful for low-budget ablations where P should control mode allocation."
147
+ ),
148
+ )
149
+ parser.add_argument("--pbudget_min_fraction", type=float, default=0.15)
150
+ parser.add_argument("--pbudget_max_fraction", type=float, default=0.75)
151
+ parser.add_argument(
152
+ "--pbudget_confidence_scale",
153
+ type=float,
154
+ default=3.0,
155
+ help="Scale applied to the P-graph contrast before mapping it to a P-basin budget.",
156
+ )
157
+ parser.add_argument("--pbasin_iterative_torsion_steps", type=int, default=3)
158
+ parser.add_argument("--pbasin_iterative_torsion_delta_scale", type=float, default=0.8)
159
+ parser.add_argument("--pbasin_torsion_base_confs", type=int, default=0)
160
+ parser.add_argument(
161
+ "--pbasin_anchor_gate",
162
+ action="store_true",
163
+ help=(
164
+ "Use P-basin candidates as reference-free manifold anchors and keep only denoise "
165
+ "candidates close to those anchors in internal pair-distance space."
166
+ ),
167
+ )
168
+ parser.add_argument("--pbasin_anchor_gate_keep_fraction", type=float, default=1.0)
169
+ parser.add_argument("--pbasin_anchor_gate_threshold", type=float, default=-1.0)
170
+ parser.add_argument("--pbasin_anchor_gate_min_keep_fraction", type=float, default=0.35)
171
+ parser.add_argument("--pbasin_anchor_gate_max_anchors", type=int, default=256)
172
+ parser.add_argument(
173
+ "--disable_stage1_pglobal",
174
+ action="store_true",
175
+ help="Ablation: replace the Stage-1 probability map P_global with zeros during denoising.",
176
+ )
177
+ parser.add_argument(
178
+ "--disable_probability_guidance",
179
+ action="store_true",
180
+ help=(
181
+ "Strict inference-only ablation. Disable every probability-guided path: "
182
+ "the P-basin branch, adaptive P-budget allocation, P-conditioned torsion "
183
+ "updates, P-aware manifold proposals, and P terms in final-pool refinement. "
184
+ "Candidate count and all non-probabilistic post-processing remain unchanged."
185
+ ),
186
+ )
187
+ parser.add_argument(
188
+ "--pglobal_control",
189
+ type=str,
190
+ default="normal",
191
+ choices=["normal", "zero", "constant", "topology", "random", "shuffle", "noisy"],
192
+ help=(
193
+ "Control ablation for the Stage-1 probability map. "
194
+ "'shuffle' preserves the map values but destroys atom-pair alignment; "
195
+ "'random' preserves only a symmetric random control; 'noisy' perturbs P."
196
+ ),
197
+ )
198
+ parser.add_argument("--pglobal_noise_std", type=float, default=0.15)
199
+ parser.add_argument("--pglobal_seed", type=int, default=20260715)
200
+ parser.add_argument("--pglobal_topology_scale", type=float, default=1.5)
201
+ parser.add_argument("--pglobal_topology_mapping", type=str, default="")
202
+ parser.add_argument(
203
+ "--inference_seed",
204
+ type=int,
205
+ default=-1,
206
+ help="Per-molecule deterministic seed for controlled P experiments; negative keeps legacy RNG behavior.",
207
+ )
208
+ parser.add_argument(
209
+ "--stage1_kernel",
210
+ type=str,
211
+ default="umap",
212
+ choices=[
213
+ "umap",
214
+ "gaussian",
215
+ "laplacian",
216
+ "student",
217
+ "cauchy",
218
+ "rational_quadratic",
219
+ "inverse_multiquadric",
220
+ "matern32",
221
+ "matern52",
222
+ "triweight",
223
+ "logistic",
224
+ ],
225
+ help="Probability-graph kernel forwarded to P-conditioned projection/refinement ablations.",
226
+ )
227
+ exp_args, remaining = parser.parse_known_args()
228
+ return exp_args, remaining
229
+
230
+
231
+ def _pgraph_budget_fraction(P, args):
232
+ min_fraction = max(0.0, min(0.95, float(getattr(args, "pbudget_min_fraction", 0.15))))
233
+ max_fraction = max(min_fraction, min(0.95, float(getattr(args, "pbudget_max_fraction", 0.75))))
234
+ if P is None or P.numel() == 0:
235
+ return min_fraction
236
+ mask = torch.triu(torch.ones_like(P, dtype=torch.bool), diagonal=1)
237
+ vals = P[mask]
238
+ vals = vals[torch.isfinite(vals)]
239
+ if vals.numel() < 4:
240
+ return min_fraction
241
+ vals = vals.detach().float()
242
+ contrast = torch.quantile(vals, 0.90) - torch.quantile(vals, 0.10)
243
+ contrast = torch.clamp(contrast, min=0.0)
244
+ scale = max(0.0, float(getattr(args, "pbudget_confidence_scale", 3.0)))
245
+ confidence = 1.0 - torch.exp(-scale * contrast)
246
+ confidence = float(torch.clamp(confidence, 0.0, 1.0).item())
247
+ return min_fraction + (max_fraction - min_fraction) * confidence
248
+
249
+
250
+ def _symmetrize_pglobal(P):
251
+ P = 0.5 * (P + P.t())
252
+ if P.numel() > 0:
253
+ P = P.clone()
254
+ P.fill_diagonal_(0.0)
255
+ return P
256
+
257
+
258
+ def _controlled_pglobal(P, args):
259
+ if P is None:
260
+ return None
261
+ if bool(getattr(args, "disable_stage1_pglobal", False)):
262
+ return torch.zeros_like(P)
263
+
264
+ mode = str(getattr(args, "pglobal_control", "normal") or "normal").lower()
265
+ if mode == "normal":
266
+ return P
267
+ if mode == "zero":
268
+ return torch.zeros_like(P)
269
+
270
+ seed = int(getattr(args, "pglobal_seed", 20260715))
271
+ seed = (seed + int(P.numel()) * 1009 + int(P.shape[0]) * 9173) % (2**31 - 1)
272
+ gen = torch.Generator(device=P.device)
273
+ gen.manual_seed(seed)
274
+
275
+ if mode == "shuffle":
276
+ perm = torch.randperm(P.shape[0], generator=gen, device=P.device)
277
+ return _symmetrize_pglobal(P[perm][:, perm])
278
+
279
+ if mode == "random":
280
+ R = torch.rand(P.shape, generator=gen, device=P.device, dtype=P.dtype)
281
+ mask = torch.triu(torch.ones_like(P, dtype=torch.bool), diagonal=1)
282
+ vals = P[mask]
283
+ vals = vals[torch.isfinite(vals)]
284
+ if vals.numel() > 1:
285
+ lo = torch.quantile(vals.detach().float(), 0.05).to(P.dtype)
286
+ hi = torch.quantile(vals.detach().float(), 0.95).to(P.dtype)
287
+ R = lo + (hi - lo).clamp_min(1e-6) * R
288
+ return _symmetrize_pglobal(R.clamp(0.0, 1.0))
289
+
290
+ if mode == "noisy":
291
+ std = max(0.0, float(getattr(args, "pglobal_noise_std", 0.15)))
292
+ noise = torch.randn(P.shape, generator=gen, device=P.device, dtype=P.dtype) * std
293
+ return _symmetrize_pglobal((P + noise).clamp(0.0, 1.0))
294
+
295
+ return P
296
+
297
+
298
+ def load_denoiser(path, device):
299
+ ckpt = torch.load(path, map_location=device)
300
+ hidden_dim = int(ckpt.get("hidden_dim", 128))
301
+ max_delta = float(ckpt.get("max_delta", 0.8))
302
+ model = NoiseTorsionDenoiser(
303
+ hidden_dim=hidden_dim,
304
+ max_delta=max_delta,
305
+ backbone=str(ckpt.get("denoiser_backbone", "mlp")),
306
+ transformer_layers=int(ckpt.get("transformer_layers", 2)),
307
+ transformer_heads=int(ckpt.get("transformer_heads", 4)),
308
+ dropout=float(ckpt.get("transformer_dropout", 0.0)),
309
+ ).to(device)
310
+ model.load_state_dict(ckpt["model_state_dict"], strict=True)
311
+ model.eval()
312
+ return model
313
+
314
+
315
+ def _pair_distance_features(confs, max_confs=None):
316
+ if not confs:
317
+ return None
318
+ if max_confs is not None and int(max_confs) > 0 and len(confs) > int(max_confs):
319
+ idx = torch.linspace(0, len(confs) - 1, int(max_confs)).round().long().tolist()
320
+ confs = [confs[i] for i in idx]
321
+ stacked = torch.stack([c.detach().cpu().float() for c in confs], dim=0)
322
+ if stacked.dim() != 3 or stacked.size(1) < 2:
323
+ return None
324
+ row, col = torch.triu_indices(stacked.size(1), stacked.size(1), offset=1)
325
+ dists = torch.norm(stacked[:, row] - stacked[:, col], dim=-1)
326
+ return torch.nan_to_num(dists, nan=0.0, posinf=0.0, neginf=0.0)
327
+
328
+
329
+ def _anchor_gate_denoise_candidates(denoise_confs, anchor_confs, args):
330
+ if not bool(getattr(args, "pbasin_anchor_gate", False)):
331
+ return denoise_confs
332
+ if not denoise_confs or not anchor_confs:
333
+ return denoise_confs
334
+
335
+ keep_fraction = min(1.0, max(0.0, float(getattr(args, "pbasin_anchor_gate_keep_fraction", 1.0))))
336
+ threshold = float(getattr(args, "pbasin_anchor_gate_threshold", -1.0))
337
+ min_keep_fraction = min(1.0, max(0.0, float(getattr(args, "pbasin_anchor_gate_min_keep_fraction", 0.35))))
338
+ if keep_fraction >= 0.999 and threshold <= 0:
339
+ return denoise_confs
340
+
341
+ denoise_feat = _pair_distance_features(denoise_confs)
342
+ anchor_feat = _pair_distance_features(
343
+ anchor_confs,
344
+ max_confs=max(1, int(getattr(args, "pbasin_anchor_gate_max_anchors", 256))),
345
+ )
346
+ if denoise_feat is None or anchor_feat is None or denoise_feat.size(1) != anchor_feat.size(1):
347
+ return denoise_confs
348
+
349
+ score_chunks = []
350
+ for start in range(0, denoise_feat.size(0), 256):
351
+ block = denoise_feat[start : start + 256]
352
+ diff = block[:, None, :] - anchor_feat[None, :, :]
353
+ score = torch.sqrt(torch.mean(diff * diff, dim=-1).clamp_min(0.0)).min(dim=1).values
354
+ score_chunks.append(score)
355
+ scores = torch.cat(score_chunks, dim=0)
356
+ order = torch.argsort(scores)
357
+
358
+ target_keep = len(denoise_confs)
359
+ if keep_fraction < 0.999:
360
+ target_keep = max(1, int(round(len(denoise_confs) * keep_fraction)))
361
+ min_keep = max(1, int(round(len(denoise_confs) * min_keep_fraction)))
362
+
363
+ if threshold > 0:
364
+ threshold_keep = torch.nonzero(scores <= threshold, as_tuple=False).flatten()
365
+ if int(threshold_keep.numel()) < min_keep:
366
+ selected = order[:min_keep]
367
+ elif int(threshold_keep.numel()) > target_keep:
368
+ selected = order[:target_keep]
369
+ else:
370
+ selected = threshold_keep
371
+ else:
372
+ selected = order[:target_keep]
373
+
374
+ selected = torch.sort(selected).values.tolist()
375
+ return [denoise_confs[i] for i in selected]
376
+
377
+
378
+ def _augment_final_torsion_snap_candidates(
379
+ confs,
380
+ *,
381
+ denoiser,
382
+ post_denoiser,
383
+ feat_i,
384
+ graph_feat_i,
385
+ P,
386
+ edge_i,
387
+ local_torsion_index,
388
+ args,
389
+ device,
390
+ ):
391
+ steps = max(0, int(getattr(args, "final_snap_steps", 0)))
392
+ if steps <= 0 or not confs:
393
+ return confs
394
+
395
+ snap_model = post_denoiser if bool(getattr(args, "final_snap_use_post_denoiser", False)) and post_denoiser is not None else denoiser
396
+ if snap_model is None:
397
+ return confs
398
+
399
+ sigma = float(getattr(args, "final_snap_sigma", 0.012))
400
+ step_scale = float(getattr(args, "final_snap_step_scale", 0.18))
401
+ max_torsions = int(getattr(args, "torsion_mode_max", 64))
402
+ max_candidates = int(getattr(args, "final_snap_max_candidates", 0))
403
+ keep_original = bool(getattr(args, "final_snap_keep_original", False))
404
+
405
+ source_confs = list(confs)
406
+ if max_candidates > 0 and len(source_confs) > max_candidates:
407
+ idx = torch.linspace(0, len(source_confs) - 1, max_candidates).round().long().tolist()
408
+ source_confs = [source_confs[int(i)] for i in idx]
409
+
410
+ snapped = []
411
+ for conf in source_confs:
412
+ y = conf.to(device=device, dtype=feat_i.dtype)
413
+ for _ in range(steps):
414
+ delta = snap_model(
415
+ node_feat=feat_i,
416
+ graph_feat=graph_feat_i,
417
+ coords=y,
418
+ P=P,
419
+ torsion_index=local_torsion_index,
420
+ sigma=float(sigma),
421
+ max_torsions=max_torsions,
422
+ )
423
+ y = apply_torsion_residuals(
424
+ y,
425
+ torsions=local_torsion_index,
426
+ deltas=delta * step_scale,
427
+ edge_index=edge_i,
428
+ max_torsions=max_torsions,
429
+ )
430
+ if torch.isfinite(y).all():
431
+ snapped.append(y.detach().cpu())
432
+
433
+ if not snapped:
434
+ return confs
435
+ if keep_original:
436
+ return list(confs) + snapped
437
+ return snapped
438
+
439
+
440
+ def _initialize_from_torsion_manifold(
441
+ coords,
442
+ torsion_index,
443
+ edge_index,
444
+ prototype,
445
+ strength,
446
+ noise_scale,
447
+ max_torsions,
448
+ ):
449
+ """Move an ETKDG seed toward one circular torsion-mixture prototype.
450
+
451
+ The update is deliberately partial: bond geometry and the established
452
+ denoising trajectory remain intact, while the mixture prior supplies a
453
+ state-specific torsion hypothesis rather than a post-hoc score.
454
+ """
455
+ rows = _torsion_rows(torsion_index)
456
+ if rows is None or rows.numel() == 0:
457
+ return coords
458
+ count = min(int(rows.size(0)), int(prototype.size(0)), int(max_torsions))
459
+ if count <= 0:
460
+ return coords
461
+ current = torsion_angles(coords, rows[:count])
462
+ target = torch.atan2(prototype[:count, 0], prototype[:count, 1]).to(current)
463
+ delta = torch.atan2(torch.sin(target - current), torch.cos(target - current))
464
+ delta = delta * float(strength)
465
+ if float(noise_scale) > 0.0:
466
+ delta = delta + torch.randn_like(delta) * float(noise_scale)
467
+ full_delta = torch.zeros(rows.size(0), dtype=coords.dtype, device=coords.device)
468
+ full_delta[:count] = delta.to(full_delta)
469
+ return apply_torsion_residuals(
470
+ coords,
471
+ torsions=torsion_index,
472
+ deltas=full_delta,
473
+ edge_index=edge_index,
474
+ max_torsions=max_torsions,
475
+ )
476
+
477
+
478
+ def _manifold_component_schedule(logits, count, uncertainty=None):
479
+ """Cover likely components once, then allocate residual slots by mass.
480
+
481
+ Mode-covering priors additionally expose torsion uncertainty. A broader
482
+ mode receives a modestly larger residual budget, while every likely mode
483
+ still receives an initial coverage slot.
484
+ """
485
+ if int(count) <= 0:
486
+ return []
487
+ weights = torch.softmax(logits.detach(), dim=-1)
488
+ allocation = weights
489
+ if uncertainty is not None and torch.is_tensor(uncertainty) and uncertainty.numel() > 0:
490
+ spread = uncertainty.detach().float().mean(dim=-1)
491
+ spread = spread / spread.mean().clamp_min(1e-6)
492
+ allocation = weights * (1.0 + 0.35 * spread)
493
+ allocation = allocation / allocation.sum().clamp_min(1e-8)
494
+ ranked = torch.argsort(allocation, descending=True).detach().cpu().tolist()
495
+ schedule = [int(index) for index in ranked[: min(int(count), len(ranked))]]
496
+ if len(schedule) < int(count):
497
+ draws = torch.multinomial(allocation, int(count) - len(schedule), replacement=True)
498
+ schedule.extend(int(index) for index in draws.detach().cpu().tolist())
499
+ return schedule
500
+
501
+
502
+ def _controlled_torsion_manifold_probability(P, args):
503
+ """Ablate only the probability-graph bridge, not the established denoiser."""
504
+ mode = str(getattr(args, "torsion_manifold_p_context_control", "normal") or "normal").lower()
505
+ if mode == "normal":
506
+ return P
507
+ if mode == "zero":
508
+ return torch.zeros_like(P)
509
+ if mode == "shuffle":
510
+ seed = int(getattr(args, "inference_seed", 20260721)) + int(P.size(0)) * 1009
511
+ generator = torch.Generator(device=P.device)
512
+ generator.manual_seed(seed % (2**31 - 1))
513
+ perm = torch.randperm(P.size(0), generator=generator, device=P.device)
514
+ return P[perm][:, perm]
515
+ raise ValueError(f"Unknown torsion-manifold P context control: {mode}")
516
+
517
+
518
+ def patched_load_model_factory(exp_args):
519
+ def load_model(_checkpoint_path, device, args_cli):
520
+ # infer_base_conformers.py still requires --checkpoint; train_torsional_denoiser uses explicit base and denoiser paths.
521
+ base_args = type("Args", (), {})()
522
+ base_args.checkpoint = exp_args.base_checkpoint
523
+ base_args.max_confs = args_cli.max_confs
524
+ base_model = load_base_model(base_args, device)
525
+ denoiser_path = str(getattr(exp_args, "denoiser_checkpoint", "") or "").strip()
526
+ # Stage-II-only / pbasin-only evaluation does not need a denoiser checkpoint.
527
+ denoiser = load_denoiser(denoiser_path, device) if denoiser_path else None
528
+ post_denoiser = None
529
+ post_path = str(getattr(exp_args, "post_denoiser_checkpoint", "") or "").strip()
530
+ if post_path:
531
+ post_denoiser = load_denoiser(post_path, device)
532
+ print(f"Loaded post-generation candidate corrector: {post_path}")
533
+ pbasin_model = None
534
+ pbasin_path = ""
535
+ if not bool(getattr(exp_args, "disable_probability_guidance", False)):
536
+ pbasin_path = str(getattr(exp_args, "pbasin_checkpoint", "") or "").strip()
537
+ if pbasin_path:
538
+ pbasin_args = type("Args", (), {})()
539
+ for key, value in vars(args_cli).items():
540
+ setattr(pbasin_args, key, value)
541
+ pbasin_args.num_modes = int(getattr(args_cli, "num_modes", 10))
542
+ pbasin_args.max_confs = int(getattr(args_cli, "max_confs", 5))
543
+ pbasin_args.torsion_mode_max = int(getattr(exp_args, "torsion_mode_max", 64))
544
+ pbasin_args.torsion_delta_scale = 3.141592653589793
545
+ pbasin_args.iterative_torsion_steps = int(getattr(exp_args, "pbasin_iterative_torsion_steps", 3))
546
+ pbasin_args.iterative_torsion_delta_scale = float(
547
+ getattr(exp_args, "pbasin_iterative_torsion_delta_scale", 0.8)
548
+ )
549
+ pbasin_args.mode_condition_strategy = "z"
550
+ pbasin_args.mode_prototype_dim = 32
551
+ pbasin_args.candidate_corrector_path = ""
552
+ pbasin_args.ensemble_checkpoints = ""
553
+ pbasin_args.ensemble_iterative_torsion_delta_scales = ""
554
+ pbasin_args.disable_stage1_pglobal = bool(getattr(exp_args, "disable_stage1_pglobal", False))
555
+ pbasin_args.pglobal_control = str(getattr(exp_args, "pglobal_control", "normal"))
556
+ pbasin_args.pglobal_noise_std = float(getattr(exp_args, "pglobal_noise_std", 0.15))
557
+ pbasin_args.pglobal_seed = int(getattr(exp_args, "pglobal_seed", 20260715))
558
+ pbasin_args.stage1_kernel = str(getattr(exp_args, "stage1_kernel", "umap"))
559
+ pbasin_loader = infer_torsion.patched_load_model_factory(pbasin_args)
560
+ pbasin_model = pbasin_loader(pbasin_path, device, pbasin_args)
561
+ print(f"Loaded P-basin hybrid checkpoint: {pbasin_path}")
562
+ torsion_manifold_prior = None
563
+ torsion_manifold_path = ""
564
+ if not bool(getattr(exp_args, "disable_probability_guidance", False)):
565
+ torsion_manifold_path = str(getattr(exp_args, "torsion_manifold_prior_path", "") or "").strip()
566
+ if torsion_manifold_path:
567
+ from torsion_manifold import ProbabilityAlignedTorsionStateMixturePrior, TorsionModeCoveringPrior, TorsionStateMixturePrior
568
+
569
+ state = torch.load(torsion_manifold_path, map_location=device, weights_only=False)
570
+ if str(state.get("model_type", "")) == "mixture_torsion_flow":
571
+ from mixture_torsion_flow import MixtureTorsionFlowModel, MixtureTorsionFlowProposalAdapter
572
+
573
+ flow_model = MixtureTorsionFlowModel(
574
+ graph_dim=int(state.get("graph_dim", 128)),
575
+ pair_dim=int(state.get("pair_dim", 515)),
576
+ components=int(state["components"]),
577
+ mode_dim=int(state["mode_dim"]),
578
+ max_torsions=int(state["max_torsions"]),
579
+ hidden_dim=int(state["hidden_dim"]),
580
+ flow_layers=int(state.get("flow_layers", 3)),
581
+ ).to(device)
582
+ flow_model.load_state_dict(state["model_state_dict"])
583
+ flow_model.eval()
584
+ torsion_manifold_prior = MixtureTorsionFlowProposalAdapter(flow_model).to(device)
585
+ prior_kind = "mixture-flow"
586
+ print(f"Loaded {prior_kind} torsion proposal adapter: {torsion_manifold_path}")
587
+ elif str(state.get("prior_type", "")) == "p_aligned_torsion_mixture":
588
+ prior_cls = ProbabilityAlignedTorsionStateMixturePrior
589
+ torsion_manifold_prior = prior_cls(
590
+ int(state.get("graph_dim", 128)),
591
+ int(state["max_torsions"]),
592
+ int(state["components"]),
593
+ int(state["hidden_dim"]),
594
+ ).to(device)
595
+ torsion_manifold_prior.load_state_dict(state["model_state_dict"])
596
+ torsion_manifold_prior.eval()
597
+ prior_kind = "P-aligned"
598
+ print(f"Loaded {prior_kind} torsion-manifold proposal prior: {torsion_manifold_path}")
599
+ else:
600
+ prior_cls = TorsionModeCoveringPrior if str(state.get("prior_type", "")) == "torsion_mode_covering" else TorsionStateMixturePrior
601
+ torsion_manifold_prior = prior_cls(
602
+ int(state.get("graph_dim", 128)),
603
+ int(state["max_torsions"]),
604
+ int(state["components"]),
605
+ int(state["hidden_dim"]),
606
+ ).to(device)
607
+ torsion_manifold_prior.load_state_dict(state["model_state_dict"])
608
+ torsion_manifold_prior.eval()
609
+ if bool(getattr(torsion_manifold_prior, "uses_budget_allocation", False)):
610
+ prior_kind = "mode-covering"
611
+ else:
612
+ prior_kind = "graph-only"
613
+ print(f"Loaded {prior_kind} torsion-manifold proposal prior: {torsion_manifold_path}")
614
+ wrapper = DenoiseWrapper(
615
+ base_model,
616
+ denoiser,
617
+ post_denoiser=post_denoiser,
618
+ pbasin_model=pbasin_model,
619
+ torsion_manifold_prior=torsion_manifold_prior,
620
+ )
621
+ print(f"Loaded base Manimol checkpoint: {exp_args.base_checkpoint}")
622
+ if denoiser_path:
623
+ print(f"Loaded torsion denoiser: {denoiser_path}")
624
+ return wrapper
625
+
626
+ return load_model
627
+
628
+
629
+ @torch.no_grad()
630
+ def sample_denoise_conformers(model, batch, graph_idx, args, model_count=None, etkdg_count=None):
631
+ base_model = model.base_model
632
+ denoiser = model.denoiser
633
+ post_denoiser = getattr(model, "post_denoiser", None)
634
+ pbasin_model = getattr(model, "pbasin_model", None)
635
+ torsion_manifold_prior = getattr(model, "torsion_manifold_prior", None)
636
+ # Stage-II-only / pbasin-only runs may intentionally omit the denoiser.
637
+ device = next(denoiser.parameters()).device if denoiser is not None else next(base_model.parameters()).device
638
+ batch = batch.to(device)
639
+
640
+ node_feat = base_model.gnn(batch)
641
+ graph_feat = base_model.pool(node_feat, batch.batch)
642
+ mask = batch.batch == graph_idx
643
+ feat_i = node_feat[mask]
644
+ if feat_i.size(0) <= 1:
645
+ return None
646
+ edge_i = base_model._get_local_edge_index(batch.edge_index, mask)
647
+ local_torsion_index = base_model._get_local_torsion_index(getattr(batch, "torsion_index", None), mask)
648
+ if local_torsion_index is None or local_torsion_index.numel() == 0:
649
+ return None
650
+ mol_ref = batch.rdmol[graph_idx] if hasattr(batch, "rdmol") else None
651
+ if mol_ref is None:
652
+ return None
653
+ seed = int(getattr(args, "inference_seed", -1))
654
+ if seed >= 0:
655
+ mol_seed = seed + int(batch.mol_id[graph_idx].item()) * 100003
656
+ torch.manual_seed(mol_seed % (2**31 - 1))
657
+ P, pair_feat_i = base_model._predict_P_global(feat_i, edge_i)
658
+ P = controlled_pglobal(P, args, mol=mol_ref)
659
+ # Exposed only for raw-pool diagnostic caching in infer_base_conformers.py.
660
+ model.last_pglobal = P.detach().cpu()
661
+ try:
662
+ a, b = base_model.predict_ab(graph_feat[graph_idx], conf_idx=0)
663
+ model.last_pgraph_kernel = (a.detach().cpu(), b.detach().cpu())
664
+ except Exception:
665
+ model.last_pgraph_kernel = None
666
+
667
+ count = int(model_count if model_count is not None else getattr(args, "num_modes", 10))
668
+ pbasin_only = bool(getattr(args, "pbasin_only", False))
669
+ pbasin_fraction = min(1.0, max(0.0, float(getattr(args, "pbasin_fraction", 0.0))))
670
+ if pbasin_only:
671
+ pbasin_fraction = 1.0
672
+ if bool(getattr(args, "pbudget_adaptive", False)):
673
+ pbasin_fraction = _pgraph_budget_fraction(P, args)
674
+ pbasin_count = 0
675
+ if pbasin_model is not None and count > 0 and pbasin_fraction > 0.0:
676
+ pbasin_count = int(round(count * pbasin_fraction))
677
+ max_pbasin_count = count if pbasin_only else max(1, count - 1)
678
+ pbasin_count = max(1, min(max_pbasin_count, pbasin_count))
679
+ denoise_count = max(0, count - pbasin_count)
680
+ manifold_fraction = min(0.80, max(0.0, float(getattr(args, "torsion_manifold_proposal_fraction", 0.0))))
681
+ manifold_count = 0
682
+ manifold_prototypes = None
683
+ manifold_spread = None
684
+ manifold_schedule = []
685
+ if torsion_manifold_prior is not None and denoise_count > 0 and manifold_fraction > 0.0:
686
+ with torch.no_grad():
687
+ if bool(getattr(torsion_manifold_prior, "uses_pair_p_context", False)):
688
+ manifold_output = torsion_manifold_prior(
689
+ graph_feat[graph_idx],
690
+ pair_feat_i.detach(),
691
+ _controlled_torsion_manifold_probability(P, args),
692
+ )
693
+ if len(manifold_output) == 3:
694
+ manifold_logits, manifold_prototypes, manifold_spread = manifold_output
695
+ else:
696
+ manifold_logits, manifold_prototypes = manifold_output
697
+ elif bool(getattr(torsion_manifold_prior, "uses_p_context", False)):
698
+ from torsion_manifold import probability_graph_torsion_context
699
+
700
+ p_context, _ = probability_graph_torsion_context(
701
+ _controlled_torsion_manifold_probability(P, args),
702
+ mol_ref,
703
+ local_torsion_index,
704
+ torsion_manifold_prior.max_torsions,
705
+ )
706
+ manifold_logits, manifold_prototypes = torsion_manifold_prior(graph_feat[graph_idx], p_context)
707
+ else:
708
+ manifold_output = torsion_manifold_prior(graph_feat[graph_idx])
709
+ if len(manifold_output) == 3:
710
+ manifold_logits, manifold_prototypes, manifold_spread = manifold_output
711
+ else:
712
+ manifold_logits, manifold_prototypes = manifold_output
713
+ manifold_count = max(1, min(denoise_count, int(round(denoise_count * manifold_fraction))))
714
+ manifold_schedule = _manifold_component_schedule(manifold_logits, manifold_count, uncertainty=manifold_spread)
715
+ base_count = int(getattr(args, "torsion_base_confs", 0))
716
+ if base_count <= 0:
717
+ base_count = max(1, denoise_count)
718
+ base_confs = infer_torsion.generate_base_conformers(
719
+ mol_ref,
720
+ num_confs=max(1, base_count),
721
+ method=getattr(args, "torsion_base_method", "etkdg"),
722
+ )
723
+ if not base_confs:
724
+ return None
725
+
726
+ steps = max(1, int(getattr(args, "denoise_steps", 10)))
727
+ sigma_max = float(getattr(args, "denoise_sigma_max", 0.75))
728
+ sigma_min = float(getattr(args, "denoise_sigma_min", 0.05))
729
+ step_scale = float(getattr(args, "denoise_step_scale", 1.0))
730
+ init_noise = float(getattr(args, "denoise_initial_noise", sigma_max))
731
+ max_torsions = int(getattr(args, "torsion_mode_max", 64))
732
+ polish_steps = max(0, int(getattr(args, "denoise_polish_steps", 0)))
733
+ polish_sigma = float(getattr(args, "denoise_polish_sigma", 0.03))
734
+ polish_scale = float(getattr(args, "denoise_polish_step_scale", 0.35))
735
+ precision_fraction = min(1.0, max(0.0, float(getattr(args, "denoise_precision_fraction", 0.0))))
736
+ precision_steps = int(getattr(args, "denoise_precision_steps", 0))
737
+ if precision_steps <= 0:
738
+ precision_steps = steps
739
+ precision_sigma_max = float(getattr(args, "denoise_precision_sigma_max", 0.45))
740
+ precision_sigma_min = float(getattr(args, "denoise_precision_sigma_min", 0.02))
741
+ precision_step_scale = float(getattr(args, "denoise_precision_step_scale", 0.65))
742
+ precision_init_noise = float(getattr(args, "denoise_precision_initial_noise", precision_sigma_max))
743
+ post_steps = max(0, int(getattr(args, "post_denoise_steps", 0)))
744
+ post_sigma = float(getattr(args, "post_denoise_sigma", 0.02))
745
+ post_step_scale = float(getattr(args, "post_denoise_step_scale", 0.35))
746
+
747
+ denoise_confs = []
748
+ for k in range(denoise_count):
749
+ # Scatter precision candidates across the whole pool instead of taking
750
+ # the first block of ETKDG seeds. ETKDG conformers are ordered, so a
751
+ # prefix split can accidentally turn into a low-energy/low-diversity
752
+ # bias. The multiplicative permutation is deterministic and keeps
753
+ # runs reproducible.
754
+ permuted_rank = ((int(k) * 9973) % max(1, int(count)) + 0.5) / max(1, int(count))
755
+ use_precision = precision_fraction > 0.0 and permuted_rank <= precision_fraction
756
+ if use_precision:
757
+ current_steps = max(1, int(precision_steps))
758
+ current_sigmas = torch.linspace(
759
+ precision_sigma_max,
760
+ precision_sigma_min,
761
+ current_steps,
762
+ device=device,
763
+ ).detach().cpu().tolist()
764
+ current_step_scale = precision_step_scale
765
+ current_init_noise = precision_init_noise
766
+ else:
767
+ current_sigmas = torch.linspace(
768
+ sigma_max,
769
+ sigma_min,
770
+ steps,
771
+ device=device,
772
+ ).detach().cpu().tolist()
773
+ current_step_scale = step_scale
774
+ current_init_noise = init_noise
775
+
776
+ y = base_confs[k % len(base_confs)]
777
+ if y.shape[0] != feat_i.size(0):
778
+ continue
779
+ y = y.to(device=device, dtype=feat_i.dtype)
780
+ # Spread state-conditioned hypotheses across the denoise branch rather
781
+ # than using an ordered prefix of ETKDG seeds. This preserves the
782
+ # original branch as a recall anchor at the same candidate budget.
783
+ is_manifold = manifold_count > 0 and ((int(k) * 7919) % max(1, denoise_count)) < manifold_count
784
+ if is_manifold and manifold_prototypes is not None and manifold_schedule:
785
+ component = manifold_schedule[len(denoise_confs) % len(manifold_schedule)]
786
+ y = _initialize_from_torsion_manifold(
787
+ y,
788
+ torsion_index=local_torsion_index,
789
+ edge_index=edge_i,
790
+ prototype=manifold_prototypes[int(component)],
791
+ strength=float(getattr(args, "torsion_manifold_proposal_strength", 0.55)),
792
+ noise_scale=float(getattr(args, "torsion_manifold_proposal_noise", 0.18)),
793
+ max_torsions=max_torsions,
794
+ )
795
+ if current_init_noise > 0:
796
+ if is_manifold:
797
+ current_init_noise *= float(getattr(args, "torsion_manifold_proposal_denoise_noise_scale", 0.50))
798
+ y, _ = noised_conformer(y, local_torsion_index, edge_i, current_init_noise, max_torsions)
799
+ for sigma in current_sigmas:
800
+ if denoiser is None:
801
+ break
802
+ delta = denoiser(
803
+ node_feat=feat_i,
804
+ graph_feat=graph_feat[graph_idx],
805
+ coords=y,
806
+ P=P,
807
+ torsion_index=local_torsion_index,
808
+ sigma=float(sigma),
809
+ max_torsions=max_torsions,
810
+ )
811
+ y = apply_torsion_residuals(
812
+ y,
813
+ torsions=local_torsion_index,
814
+ deltas=delta * current_step_scale,
815
+ edge_index=edge_i,
816
+ max_torsions=max_torsions,
817
+ )
818
+ for _ in range(polish_steps):
819
+ if denoiser is None:
820
+ break
821
+ delta = denoiser(
822
+ node_feat=feat_i,
823
+ graph_feat=graph_feat[graph_idx],
824
+ coords=y,
825
+ P=P,
826
+ torsion_index=local_torsion_index,
827
+ sigma=float(polish_sigma),
828
+ max_torsions=max_torsions,
829
+ )
830
+ y = apply_torsion_residuals(
831
+ y,
832
+ torsions=local_torsion_index,
833
+ deltas=delta * polish_scale,
834
+ edge_index=edge_i,
835
+ max_torsions=max_torsions,
836
+ )
837
+ if post_denoiser is not None and post_steps > 0:
838
+ for _ in range(post_steps):
839
+ delta = post_denoiser(
840
+ node_feat=feat_i,
841
+ graph_feat=graph_feat[graph_idx],
842
+ coords=y,
843
+ P=P,
844
+ torsion_index=local_torsion_index,
845
+ sigma=float(post_sigma),
846
+ max_torsions=max_torsions,
847
+ )
848
+ y = apply_torsion_residuals(
849
+ y,
850
+ torsions=local_torsion_index,
851
+ deltas=delta * post_step_scale,
852
+ edge_index=edge_i,
853
+ max_torsions=max_torsions,
854
+ )
855
+ denoise_confs.append(y.detach().cpu())
856
+
857
+ pbasin_normal_count = 0
858
+ pbasin_mirror_count = 0
859
+ pbasin_etkdg_count = 0
860
+ pbasin_confs = []
861
+ if pbasin_model is not None and pbasin_count > 0:
862
+ p_args = type("Args", (), {})()
863
+ for key, value in vars(args).items():
864
+ setattr(p_args, key, value)
865
+ p_args.iterative_torsion_steps = int(getattr(args, "pbasin_iterative_torsion_steps", 3))
866
+ p_args.iterative_torsion_delta_scale = float(getattr(args, "pbasin_iterative_torsion_delta_scale", 0.8))
867
+ p_args.torsion_base_confs = int(getattr(args, "pbasin_torsion_base_confs", 0))
868
+ p_args.torsion_base_method = str(getattr(args, "torsion_base_method", "etkdg"))
869
+ p_args.etkdg_candidate_pool = False
870
+ p_args.use_etkdg = bool(getattr(args, "use_etkdg", True))
871
+ p_args.use_egnn_refine = False
872
+ p_args.use_mmff = False
873
+ p_args.use_torsion_refine = False
874
+ p_args.mirror_ratio = 0.0
875
+ result = infer_torsion._sample_torsion_conformers_single(
876
+ pbasin_model,
877
+ batch,
878
+ graph_idx,
879
+ p_args,
880
+ model_count=pbasin_count,
881
+ etkdg_count=0,
882
+ )
883
+ if result is not None:
884
+ p_confs, pbasin_normal_count, pbasin_mirror_count, pbasin_etkdg_count = result
885
+ for conf in p_confs:
886
+ pbasin_confs.append(conf.detach().cpu())
887
+
888
+ gated_denoise_confs = _anchor_gate_denoise_candidates(denoise_confs, pbasin_confs, args)
889
+ out_confs = list(gated_denoise_confs) + list(pbasin_confs)
890
+ actual_etkdg_count = int(pbasin_etkdg_count)
891
+ all_confs = list(out_confs)
892
+ if args.use_etkdg and args.etkdg_candidate_pool and mol_ref is not None and int(etkdg_count or 0) > 0:
893
+ etkdg_confs = infer_base_conformers.generate_etkdg_conformers(mol_ref, num_confs=int(etkdg_count))
894
+ for conf in etkdg_confs:
895
+ if conf.shape[0] == feat_i.size(0):
896
+ all_confs.append(conf)
897
+ actual_etkdg_count += 1
898
+ all_confs = _augment_final_torsion_snap_candidates(
899
+ all_confs,
900
+ denoiser=denoiser,
901
+ post_denoiser=post_denoiser,
902
+ feat_i=feat_i,
903
+ graph_feat_i=graph_feat[graph_idx],
904
+ P=P,
905
+ edge_i=edge_i,
906
+ local_torsion_index=local_torsion_index,
907
+ args=args,
908
+ device=device,
909
+ )
910
+ if not all_confs:
911
+ return None
912
+ return (
913
+ torch.stack(all_confs, dim=0),
914
+ int(len(gated_denoise_confs)) + int(pbasin_normal_count),
915
+ int(pbasin_mirror_count),
916
+ int(actual_etkdg_count),
917
+ )
918
+
919
+
920
+ def main():
921
+ exp_args, remaining = parse_denoise_args()
922
+ original_argv = sys.argv
923
+ original_parse_args = infer_base_conformers.parse_args
924
+
925
+ def patched_parse_args():
926
+ try:
927
+ sys.argv = [original_argv[0]] + remaining
928
+ args = original_parse_args()
929
+ finally:
930
+ sys.argv = original_argv
931
+ args.base_checkpoint = str(exp_args.base_checkpoint)
932
+ args.denoiser_checkpoint = str(exp_args.denoiser_checkpoint)
933
+ args.denoise_steps = int(exp_args.denoise_steps)
934
+ args.denoise_sigma_max = float(exp_args.denoise_sigma_max)
935
+ args.denoise_sigma_min = float(exp_args.denoise_sigma_min)
936
+ args.denoise_step_scale = float(exp_args.denoise_step_scale)
937
+ args.denoise_initial_noise = float(exp_args.denoise_initial_noise)
938
+ args.pbasin_only = bool(exp_args.pbasin_only)
939
+ args.denoise_polish_steps = int(exp_args.denoise_polish_steps)
940
+ args.denoise_polish_sigma = float(exp_args.denoise_polish_sigma)
941
+ args.denoise_polish_step_scale = float(exp_args.denoise_polish_step_scale)
942
+ args.denoise_precision_fraction = float(exp_args.denoise_precision_fraction)
943
+ args.denoise_precision_steps = int(exp_args.denoise_precision_steps)
944
+ args.denoise_precision_sigma_max = float(exp_args.denoise_precision_sigma_max)
945
+ args.denoise_precision_sigma_min = float(exp_args.denoise_precision_sigma_min)
946
+ args.denoise_precision_step_scale = float(exp_args.denoise_precision_step_scale)
947
+ args.denoise_precision_initial_noise = float(exp_args.denoise_precision_initial_noise)
948
+ args.post_denoiser_checkpoint = str(exp_args.post_denoiser_checkpoint)
949
+ args.post_denoise_steps = int(exp_args.post_denoise_steps)
950
+ args.post_denoise_sigma = float(exp_args.post_denoise_sigma)
951
+ args.post_denoise_step_scale = float(exp_args.post_denoise_step_scale)
952
+ args.final_snap_steps = int(exp_args.final_snap_steps)
953
+ args.final_snap_sigma = float(exp_args.final_snap_sigma)
954
+ args.final_snap_step_scale = float(exp_args.final_snap_step_scale)
955
+ args.final_snap_max_candidates = int(exp_args.final_snap_max_candidates)
956
+ args.final_snap_use_post_denoiser = bool(exp_args.final_snap_use_post_denoiser)
957
+ args.final_snap_keep_original = bool(exp_args.final_snap_keep_original)
958
+ args.torsion_mode_max = int(exp_args.torsion_mode_max)
959
+ args.torsion_manifold_prior_path = str(exp_args.torsion_manifold_prior_path)
960
+ args.torsion_manifold_proposal_fraction = float(exp_args.torsion_manifold_proposal_fraction)
961
+ args.torsion_manifold_proposal_strength = float(exp_args.torsion_manifold_proposal_strength)
962
+ args.torsion_manifold_proposal_noise = float(exp_args.torsion_manifold_proposal_noise)
963
+ args.torsion_manifold_proposal_denoise_noise_scale = float(
964
+ exp_args.torsion_manifold_proposal_denoise_noise_scale
965
+ )
966
+ args.torsion_manifold_p_context_control = str(exp_args.torsion_manifold_p_context_control)
967
+ args.manifold_use_mode_p = bool(exp_args.manifold_use_mode_p)
968
+ args.torsion_base_method = str(exp_args.torsion_base_method)
969
+ args.torsion_base_confs = int(exp_args.torsion_base_confs)
970
+ args.pbasin_checkpoint = str(exp_args.pbasin_checkpoint)
971
+ args.pbasin_fraction = float(exp_args.pbasin_fraction)
972
+ args.pbudget_adaptive = bool(exp_args.pbudget_adaptive)
973
+ args.pbudget_min_fraction = float(exp_args.pbudget_min_fraction)
974
+ args.pbudget_max_fraction = float(exp_args.pbudget_max_fraction)
975
+ args.pbudget_confidence_scale = float(exp_args.pbudget_confidence_scale)
976
+ args.pbasin_iterative_torsion_steps = int(exp_args.pbasin_iterative_torsion_steps)
977
+ args.pbasin_iterative_torsion_delta_scale = float(exp_args.pbasin_iterative_torsion_delta_scale)
978
+ args.pbasin_torsion_base_confs = int(exp_args.pbasin_torsion_base_confs)
979
+ args.pbasin_anchor_gate = bool(exp_args.pbasin_anchor_gate)
980
+ args.pbasin_anchor_gate_keep_fraction = float(exp_args.pbasin_anchor_gate_keep_fraction)
981
+ args.pbasin_anchor_gate_threshold = float(exp_args.pbasin_anchor_gate_threshold)
982
+ args.pbasin_anchor_gate_min_keep_fraction = float(exp_args.pbasin_anchor_gate_min_keep_fraction)
983
+ args.pbasin_anchor_gate_max_anchors = int(exp_args.pbasin_anchor_gate_max_anchors)
984
+ args.disable_stage1_pglobal = bool(exp_args.disable_stage1_pglobal)
985
+ args.disable_probability_guidance = bool(exp_args.disable_probability_guidance)
986
+ args.pglobal_control = str(exp_args.pglobal_control)
987
+ args.pglobal_noise_std = float(exp_args.pglobal_noise_std)
988
+ args.pglobal_seed = int(exp_args.pglobal_seed)
989
+ args.pglobal_topology_scale = float(exp_args.pglobal_topology_scale)
990
+ args.pglobal_topology_mapping = str(getattr(exp_args, "pglobal_topology_mapping", "") or "")
991
+ args.inference_seed = int(exp_args.inference_seed)
992
+ args.stage1_kernel = str(exp_args.stage1_kernel)
993
+ if args.disable_probability_guidance:
994
+ # Preserve the sampling budget and non-probabilistic stages while
995
+ # removing every inference-time route through the learned graph.
996
+ args.disable_stage1_pglobal = True
997
+ args.pglobal_control = "zero"
998
+ args.pbasin_checkpoint = ""
999
+ args.pbasin_fraction = 0.0
1000
+ args.pbudget_adaptive = False
1001
+ args.pbasin_anchor_gate = False
1002
+ args.torsion_manifold_prior_path = ""
1003
+ args.torsion_manifold_proposal_fraction = 0.0
1004
+ args.manifold_use_mode_p = False
1005
+ args.precision_refine_pgraph_weight = 0.0
1006
+ args.ultra_refine_pgraph_weight = 0.0
1007
+ args.pgraph_reconstruct_steps = 0
1008
+ args.pgraph_direct_candidates = 0
1009
+ args.pgraph_direct_only = False
1010
+ if "--etkdg_candidate_pool" not in remaining:
1011
+ args.etkdg_candidate_pool = False
1012
+ return args
1013
+
1014
+ infer_base_conformers.parse_args = patched_parse_args
1015
+ infer_base_conformers.load_model = patched_load_model_factory(exp_args)
1016
+ infer_base_conformers.sample_conformers = sample_denoise_conformers
1017
+ infer_base_conformers.main()
1018
+
1019
+
1020
+ if __name__ == "__main__":
1021
+ main()