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,329 @@
1
+ #!/usr/bin/env python3
2
+ """Train a mean--dispersion-conditioned mixture prior over torsion states.
3
+
4
+ This is intentionally a proposal/selection prior, not a coordinate decoder.
5
+ The established ManiMol generator remains frozen, so any downstream change can
6
+ be attributed to torsion-state manifold organization rather than a changed
7
+ candidate pool.
8
+ """
9
+ from __future__ import annotations
10
+
11
+ import argparse
12
+ import os
13
+
14
+ import torch
15
+ import torch.nn.functional as F
16
+ from torch_geometric.loader import DataLoader
17
+ from tqdm import tqdm
18
+
19
+ from dataset import QM9Dataset
20
+ from infer_base_conformers import build_model_args, checkpoint_max_confs, get_split_indices
21
+ from models.model0 import GNNEncoder, _torsion_rows, torsion_angles
22
+ from torsion_manifold import (
23
+ ProbabilityAlignedTorsionStateMixturePrior,
24
+ TorsionStateMixturePrior,
25
+ mixture_torsion_nll,
26
+ )
27
+ from models.mean_dispersion_torsion_context import mean_dispersion_torsion_context
28
+ from trainer import MoleculeGroupedBatchSampler
29
+
30
+
31
+ def parse_args():
32
+ parser = argparse.ArgumentParser(description="Train a torsion-state mixture manifold prior")
33
+ parser.add_argument("--fixed_dump_name", action="store_true")
34
+ parser.add_argument("--data_root", default="data")
35
+ parser.add_argument("--dataset", default="Drugs")
36
+ parser.add_argument("--raw_prefix", default="geom_drugs")
37
+ parser.add_argument("--train_raw_filename", default=None)
38
+ parser.add_argument("--val_raw_filename", default=None)
39
+ parser.add_argument("--test_raw_filename", default=None)
40
+ parser.add_argument("--checkpoint", required=True)
41
+ parser.add_argument("--output", required=True)
42
+ parser.add_argument("--device", default="cpu")
43
+ parser.add_argument("--max_confs", type=int, default=5,
44
+ help="Stage-I capacity; 0 reads it from --checkpoint.")
45
+ parser.add_argument("--max_torsions", type=int, default=64)
46
+ parser.add_argument("--components", type=int, default=8)
47
+ parser.add_argument("--hidden_dim", type=int, default=160)
48
+ parser.add_argument("--concentration", type=float, default=12.0)
49
+ parser.add_argument("--entropy_weight", type=float, default=0.0)
50
+ parser.add_argument("--coverage_weight", type=float, default=0.50)
51
+ parser.add_argument("--coverage_temperature", type=float, default=0.10)
52
+ parser.add_argument(
53
+ "--set_affinity_alignment",
54
+ action="store_true",
55
+ help="Align mixture-mode co-assignments to a UMAP-kernel teacher graph over reference torsion states.",
56
+ )
57
+ parser.add_argument("--set_affinity_weight", type=float, default=0.20)
58
+ parser.add_argument(
59
+ "--mean_dispersion_aligned",
60
+ action="store_true",
61
+ help="Condition torsion prototypes on Stage-I mean and dispersion cut statistics.",
62
+ )
63
+ parser.add_argument("--epochs", type=int, default=60)
64
+ parser.add_argument("--lr", type=float, default=5e-4)
65
+ parser.add_argument("--batch_size", type=int, default=24)
66
+ parser.add_argument("--num_workers", type=int, default=0)
67
+ parser.add_argument("--limit_train_molecules", type=int, default=200)
68
+ parser.add_argument("--limit_valid_molecules", type=int, default=50)
69
+ parser.add_argument("--seed", type=int, default=20260721)
70
+ parser.add_argument(
71
+ "--debug_gradients",
72
+ action="store_true",
73
+ help="Print one-batch gradient and parameter-change diagnostics, then continue normally.",
74
+ )
75
+ parser.add_argument(
76
+ "--reuse_existing_cache",
77
+ action="store_true",
78
+ help="Reuse the existing full processed cache instead of rebuilding a train/validation-only cache.",
79
+ )
80
+ return parser.parse_args()
81
+
82
+
83
+ def choose_subset(dataset, indices, limit):
84
+ seen, keep = set(), []
85
+ for index in indices.tolist() if hasattr(indices, "tolist") else indices:
86
+ molecule_id = int(dataset[int(index)].mol_id.item())
87
+ if molecule_id not in seen and int(limit) > 0 and len(seen) >= int(limit):
88
+ continue
89
+ seen.add(molecule_id)
90
+ keep.append(int(index))
91
+ return dataset[keep]
92
+
93
+
94
+ def load_base(path, device):
95
+ checkpoint_confs = checkpoint_max_confs(path)
96
+ cli = argparse.Namespace(
97
+ max_confs=int(checkpoint_confs), num_modes=10, use_mode_specific_p=False,
98
+ mode_p_delta_scale=1.0, deterministic_modes=True,
99
+ use_torsion_residual=False, torsion_residual_max=64,
100
+ torsion_residual_scale=1.0,
101
+ )
102
+ model = GNNEncoder(args=build_model_args(cli), config={"model": {"model_level": "graph"}}).to(device)
103
+ state = torch.load(path, map_location=device, weights_only=False)
104
+ model.load_state_dict(state.get("model_state_dict", state.get("state_dict", state)), strict=False)
105
+ model.eval()
106
+ for parameter in model.parameters():
107
+ parameter.requires_grad_(False)
108
+ return model
109
+
110
+
111
+ def torsion_affinity_teacher(target, valid_mask, a, b):
112
+ """UMAP affinity graph over the observed torsion-state ensemble.
113
+
114
+ Nodes are conformers of one molecule rather than atoms. The frozen
115
+ Stage-1 kernel supplies molecule-adaptive positive ``a`` and ``b``;
116
+ torsion distances make the teacher periodic and chemically meaningful.
117
+ """
118
+ vectors = target[:, valid_mask]
119
+ if vectors.size(0) < 2 or vectors.size(1) == 0:
120
+ return None
121
+ cosine = torch.einsum("mtd,ntd->mnt", vectors, vectors).clamp(-1.0, 1.0)
122
+ distance = (1.0 - cosine).mean(dim=-1)
123
+ a = torch.as_tensor(a, dtype=distance.dtype, device=distance.device).reshape(()).abs().clamp_min(1e-5)
124
+ b = torch.as_tensor(b, dtype=distance.dtype, device=distance.device).reshape(()).abs().clamp_min(1e-5)
125
+ return 1.0 / (1.0 + a * distance.clamp_min(1e-8).pow(2.0 * b))
126
+
127
+
128
+ def set_affinity_alignment(distance, logits, target, valid_mask, a, b):
129
+ """Teacher-student agreement between reference and mode affinity graphs."""
130
+ teacher = torsion_affinity_teacher(target, valid_mask, a, b)
131
+ if teacher is None:
132
+ zero = distance.sum() * 0.0
133
+ return zero, zero, zero
134
+ assignments = torch.softmax(F.log_softmax(logits, dim=-1).view(1, -1) - distance, dim=-1)
135
+ student = (assignments @ assignments.transpose(0, 1)).clamp(1e-5, 1.0 - 1e-5)
136
+ off_diagonal = ~torch.eye(student.size(0), dtype=torch.bool, device=student.device)
137
+ if not off_diagonal.any():
138
+ zero = distance.sum() * 0.0
139
+ return zero, zero, zero
140
+ loss = F.binary_cross_entropy(student[off_diagonal], teacher.detach()[off_diagonal])
141
+ baseline_value = teacher[off_diagonal].mean().clamp(1e-5, 1.0 - 1e-5)
142
+ baseline = F.binary_cross_entropy(torch.full_like(teacher[off_diagonal], baseline_value), teacher.detach()[off_diagonal])
143
+ return loss, teacher[off_diagonal].mean(), baseline
144
+
145
+
146
+ def group_record(args, base, prior, batch, graph_indices):
147
+ first = int(graph_indices[0])
148
+ atom_mask = batch.batch == first
149
+ positions = [batch.pos[batch.batch == int(index)] for index in graph_indices]
150
+ if len(positions) < 2 or any(position.size() != positions[0].size() for position in positions):
151
+ return None
152
+ with torch.no_grad():
153
+ node = base.gnn(batch)
154
+ graph = base.pool(node, batch.batch)[first].detach()
155
+ torsion = base._get_local_torsion_index(getattr(batch, "torsion_index", None), atom_mask)
156
+ rows = _torsion_rows(torsion)
157
+ if rows is None or rows.numel() == 0:
158
+ return None
159
+ rows = rows[: int(args.max_torsions)].long()
160
+ valid = (rows >= 0).all(dim=1) & (rows < positions[0].size(0)).all(dim=1)
161
+ rows = rows[valid]
162
+ if rows.numel() == 0:
163
+ return None
164
+ target = torch.zeros(len(positions), int(args.max_torsions), 2, device=positions[0].device)
165
+ for index, position in enumerate(positions):
166
+ angles = torsion_angles(position, rows)
167
+ target[index, : rows.size(0)] = torch.stack([angles.sin(), angles.cos()], dim=-1)
168
+ valid_mask = torch.zeros(int(args.max_torsions), dtype=torch.bool, device=target.device)
169
+ valid_mask[: rows.size(0)] = True
170
+ edge = base._get_local_edge_index(batch.edge_index, atom_mask)
171
+ with torch.no_grad():
172
+ p_mean, p_disp, _ = base._predict_mean_dispersion(node[atom_mask], edge)
173
+ mol = batch.rdmol[first] if hasattr(batch, "rdmol") else None
174
+ torsion_context, _ = mean_dispersion_torsion_context(p_mean, p_disp, mol, torsion, args.max_torsions)
175
+ logits, prototypes = prior(graph, torsion_context, valid_mask)
176
+ nll, distance = mixture_torsion_nll(logits, prototypes, target, valid_mask, args.concentration)
177
+ temperature = max(float(args.coverage_temperature), 1e-6)
178
+ coverage_loss = (-temperature * torch.logsumexp(-distance / temperature, dim=-1)).mean()
179
+ weights = torch.softmax(logits, dim=-1)
180
+ entropy_penalty = (weights * torch.log(weights.clamp_min(1e-8))).sum()
181
+ affinity_loss = target.sum() * 0.0
182
+ affinity_mean = target.sum() * 0.0
183
+ affinity_baseline = target.sum() * 0.0
184
+ if bool(args.set_affinity_alignment):
185
+ with torch.no_grad():
186
+ a, b = base.predict_ab(graph, conf_idx=0)
187
+ affinity_loss, affinity_mean, affinity_baseline = set_affinity_alignment(
188
+ distance, logits, target, valid_mask, a, b
189
+ )
190
+ loss = (nll
191
+ + float(args.coverage_weight) * coverage_loss
192
+ + float(args.entropy_weight) * entropy_penalty
193
+ + float(args.set_affinity_weight) * affinity_loss)
194
+ return loss, {
195
+ "nll": nll.detach(),
196
+ "coverage": coverage_loss.detach(),
197
+ "best_torsion": distance.min(dim=1).values.mean().detach(),
198
+ "entropy": (-(weights * torch.log(weights.clamp_min(1e-8))).sum()).detach(),
199
+ "torsions": torch.tensor(float(rows.size(0)), device=target.device),
200
+ "affinity": affinity_loss.detach(),
201
+ "affinity_mean": affinity_mean.detach(),
202
+ "affinity_baseline": affinity_baseline.detach(),
203
+ }
204
+
205
+
206
+ def run_epoch(args, base, prior, loader, optimizer=None, label="Train"):
207
+ training = optimizer is not None
208
+ prior.train(training)
209
+ totals = {key: 0.0 for key in ("loss", "nll", "coverage", "best_torsion", "entropy", "torsions", "affinity", "affinity_mean", "affinity_baseline")}
210
+ count = 0
211
+ debug_done = False
212
+ for batch in tqdm(loader, desc=label):
213
+ batch = batch.to(args.device)
214
+ groups = {}
215
+ for graph_index, molecule_id in enumerate(batch.mol_id.detach().cpu().tolist()):
216
+ groups.setdefault(int(molecule_id), []).append(graph_index)
217
+ records = [group_record(args, base, prior, batch, indices) for indices in groups.values()]
218
+ records = [record for record in records if record is not None]
219
+ if not records:
220
+ continue
221
+ loss = torch.stack([record[0] for record in records]).mean()
222
+ if training:
223
+ optimizer.zero_grad(set_to_none=True)
224
+ loss.backward()
225
+ if bool(getattr(args, "debug_gradients", False)) and not debug_done:
226
+ grad_sq = 0.0
227
+ for parameter in prior.parameters():
228
+ if parameter.grad is not None:
229
+ grad_sq += float(parameter.grad.detach().pow(2).sum())
230
+ before = next(prior.parameters()).detach().clone()
231
+ print(
232
+ "[debug_gradients] batch_loss={:.8f} grad_norm={:.8e} param_norm={:.8e}".format(
233
+ float(loss.detach()), grad_sq ** 0.5, float(before.norm())
234
+ ),
235
+ flush=True,
236
+ )
237
+ torch.nn.utils.clip_grad_norm_(prior.parameters(), 3.0)
238
+ optimizer.step()
239
+ if bool(getattr(args, "debug_gradients", False)) and not debug_done:
240
+ after = next(prior.parameters()).detach()
241
+ print(
242
+ "[debug_gradients] first_param_delta={:.8e}".format(
243
+ float((after - before).norm())
244
+ ),
245
+ flush=True,
246
+ )
247
+ debug_done = True
248
+ for record_loss, metrics in records:
249
+ totals["loss"] += float(record_loss.detach())
250
+ for key, value in metrics.items():
251
+ totals[key] += float(value)
252
+ count += len(records)
253
+ return {key: value / max(1, count) for key, value in totals.items()}
254
+
255
+
256
+ def main():
257
+ args = parse_args()
258
+ if int(args.max_confs) == 0:
259
+ args.max_confs = checkpoint_max_confs(args.checkpoint)
260
+ print(f"Auto-resolved max_confs={args.max_confs} from base checkpoint.")
261
+ torch.manual_seed(args.seed)
262
+ args.device = "cuda" if args.device == "auto" and torch.cuda.is_available() else args.device
263
+ device = torch.device(args.device)
264
+ os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
265
+ # Stage-II never consumes test conformers during optimization. Avoid
266
+ # materializing the full held-out split in the InMemoryDataset; for debug
267
+ # runs, also build only the requested train/validation molecule subsets.
268
+ if bool(args.reuse_existing_cache):
269
+ process_train_limit = 0
270
+ process_valid_limit = 0
271
+ process_test_limit = 0
272
+ else:
273
+ process_train_limit = int(args.limit_train_molecules) if int(args.limit_train_molecules) > 0 else 0
274
+ process_valid_limit = int(args.limit_valid_molecules) if int(args.limit_valid_molecules) > 0 else 0
275
+ process_test_limit = 0
276
+ dataset = QM9Dataset(
277
+ name=args.dataset,
278
+ root=args.data_root,
279
+ max_confs=args.max_confs,
280
+ raw_prefix=args.raw_prefix,
281
+ train_raw_filename=args.train_raw_filename,
282
+ val_raw_filename=args.val_raw_filename,
283
+ test_raw_filename=args.test_raw_filename,
284
+ process_train_mol_limit=process_train_limit,
285
+ process_val_mol_limit=process_valid_limit,
286
+ process_test_mol_limit=process_test_limit,
287
+ )
288
+ train_set = choose_subset(dataset, get_split_indices(dataset, "train"), args.limit_train_molecules)
289
+ valid_set = choose_subset(dataset, get_split_indices(dataset, "valid"), args.limit_valid_molecules)
290
+ train_loader = DataLoader(train_set, batch_sampler=MoleculeGroupedBatchSampler(train_set, args.batch_size, shuffle=True), num_workers=args.num_workers)
291
+ valid_loader = DataLoader(valid_set, batch_sampler=MoleculeGroupedBatchSampler(valid_set, args.batch_size, shuffle=False), num_workers=args.num_workers)
292
+ base = load_base(args.checkpoint, device)
293
+ if not args.mean_dispersion_aligned:
294
+ raise ValueError("This runner requires --mean-dispersion-aligned.")
295
+ prior = ProbabilityAlignedTorsionStateMixturePrior(128, args.max_torsions, args.components, args.hidden_dim).to(device)
296
+ optimizer = torch.optim.AdamW(prior.parameters(), lr=args.lr, weight_decay=1e-4)
297
+ best = float("inf")
298
+ for epoch in range(args.epochs):
299
+ train = run_epoch(args, base, prior, train_loader, optimizer, f"Train E[{epoch}]")
300
+ with torch.no_grad():
301
+ valid = run_epoch(args, base, prior, valid_loader, None, f"Valid E[{epoch}]")
302
+ print(
303
+ "epoch={:03d} train={:.5f} valid={:.5f} nll={:.5f} coverage={:.5f} best_torsion={:.5f} entropy={:.4f} active_torsions={:.1f}".format(
304
+ epoch, train["loss"], valid["loss"], valid["nll"], valid["coverage"], valid["best_torsion"], valid["entropy"], valid["torsions"]
305
+ )
306
+ )
307
+ payload = {
308
+ "model_state_dict": prior.state_dict(), "graph_dim": 128,
309
+ "max_torsions": args.max_torsions, "components": args.components,
310
+ "hidden_dim": args.hidden_dim, "concentration": args.concentration,
311
+ "prior_type": "mean_dispersion_aligned_torsion_mixture",
312
+ "context_dim": 4,
313
+ "context_schema": ["mean", "dispersion", "mean_q90", "mean_max"],
314
+ "coverage_weight": float(args.coverage_weight),
315
+ "coverage_temperature": float(args.coverage_temperature),
316
+ "epoch": int(epoch),
317
+ "valid_loss": float(valid["loss"]),
318
+ "valid_nll": float(valid["nll"]),
319
+ "valid_coverage": float(valid["coverage"]),
320
+ }
321
+ torch.save({**payload, "optimizer_state_dict": optimizer.state_dict()}, os.path.join(os.path.dirname(args.output), "latest.pth"))
322
+ if valid["loss"] < best:
323
+ best = valid["loss"]
324
+ torch.save(payload, args.output)
325
+ print(f"New best torsion manifold prior: {best:.5f}")
326
+
327
+
328
+ if __name__ == "__main__":
329
+ main()
@@ -0,0 +1,235 @@
1
+ #!/usr/bin/env python3
2
+ """Stage-2 training where Stage-1 probability graphs control mode basins.
3
+
4
+ The previous torsion Stage-2 variants mostly used the learned probability graph
5
+ as a soft decoder feature. In the high-candidate regime this feature can be
6
+ ignored. This branch makes Stage-1 matter in a harder way: reference
7
+ conformers of the same molecule are clustered by their Stage-1/UMAP probability
8
+ graphs, and each cluster is mapped to a fixed mode or mode window. Thus a mode
9
+ can only learn references assigned to its probability-basin.
10
+ """
11
+
12
+ from __future__ import annotations
13
+
14
+ import logging
15
+ import sys
16
+ import warnings
17
+ from argparse import ArgumentParser
18
+ from typing import Any, Dict, List, Tuple
19
+
20
+ import torch
21
+ from rdkit import RDLogger
22
+
23
+ import train_torsion_generator
24
+ from models.model0 import prob_low_dim_kernel
25
+
26
+
27
+ warnings.filterwarnings("ignore", category=DeprecationWarning)
28
+ RDLogger.DisableLog("rdApp.*")
29
+
30
+ logging.basicConfig(
31
+ level=logging.INFO,
32
+ format="%(asctime)s %(levelname)s %(name)s: %(message)s",
33
+ )
34
+ logger = logging.getLogger(__name__)
35
+
36
+
37
+ def parse_pbasin_args():
38
+ parser = ArgumentParser(add_help=False)
39
+ parser.add_argument(
40
+ "--p_basin_metric",
41
+ type=str,
42
+ default="l1",
43
+ choices=["l1", "l2", "bce"],
44
+ help="Distance used to cluster reference probability graphs into basins.",
45
+ )
46
+ parser.add_argument(
47
+ "--p_basin_topk_pairs",
48
+ type=int,
49
+ default=256,
50
+ help="Use the most informative atom pairs from the mean probability graph; 0 uses all pairs.",
51
+ )
52
+ parser.add_argument(
53
+ "--p_basin_min_topo",
54
+ type=int,
55
+ default=2,
56
+ help="Ignore atom pairs closer than this graph-hop distance when clustering P basins.",
57
+ )
58
+ parser.add_argument(
59
+ "--p_basin_anchor_mode",
60
+ type=str,
61
+ default="maxmean",
62
+ choices=["maxmean", "first"],
63
+ help="How to choose the first farthest-point anchor in probability-graph space.",
64
+ )
65
+ exp_args, remaining = parser.parse_known_args()
66
+ return exp_args, remaining
67
+
68
+
69
+ def parse_all_args():
70
+ exp_args, remaining = parse_pbasin_args()
71
+ original_argv = sys.argv
72
+ try:
73
+ sys.argv = [original_argv[0]] + remaining
74
+ args = train_torsion_generator.parse_all_args()
75
+ finally:
76
+ sys.argv = original_argv
77
+ for key, value in vars(exp_args).items():
78
+ setattr(args, key, value)
79
+ return args
80
+
81
+
82
+ class ProbabilityBasinTrainer(train_torsion_generator.TorsionTrainer):
83
+ """Torsion trainer with Stage-1 probability-basin mode assignment."""
84
+
85
+ def _topology_distance(self, edge_index: torch.Tensor, n: int, device) -> torch.Tensor:
86
+ dist = torch.full((n, n), 1e6, device=device)
87
+ idx = torch.arange(n, device=device)
88
+ dist[idx, idx] = 0.0
89
+ if edge_index is not None and edge_index.numel() > 0:
90
+ row, col = edge_index.to(device=device)
91
+ valid = (row >= 0) & (row < n) & (col >= 0) & (col < n)
92
+ row = row[valid]
93
+ col = col[valid]
94
+ dist[row, col] = 1.0
95
+ dist[col, row] = 1.0
96
+ for k in range(n):
97
+ dist = torch.minimum(dist, dist[:, k:k + 1] + dist[k:k + 1, :])
98
+ return dist
99
+
100
+ def _pbasin_pair_mask(
101
+ self,
102
+ mean_q: torch.Tensor,
103
+ edge_i: torch.Tensor,
104
+ ) -> torch.Tensor:
105
+ n = int(mean_q.size(0))
106
+ upper = torch.triu(torch.ones(n, n, dtype=torch.bool, device=mean_q.device), diagonal=1)
107
+ topo = self._topology_distance(edge_i, n, mean_q.device)
108
+ min_topo = int(getattr(self.args, "p_basin_min_topo", 2))
109
+ valid = upper & (topo >= float(min_topo)) & (topo < 1e5)
110
+ topk = int(getattr(self.args, "p_basin_topk_pairs", 256))
111
+ if topk <= 0 or int(valid.sum().item()) <= topk:
112
+ return valid
113
+ score = torch.where(valid, mean_q.detach().clamp(0.0, 1.0), torch.zeros_like(mean_q))
114
+ flat_idx = torch.topk(score.reshape(-1), k=topk, largest=True).indices
115
+ mask = torch.zeros_like(valid)
116
+ mask.reshape(-1)[flat_idx] = True
117
+ return mask & valid
118
+
119
+ def _pbasin_distance(self, qs: List[torch.Tensor], mask: torch.Tensor) -> torch.Tensor:
120
+ n = len(qs)
121
+ dist = qs[0].new_zeros((n, n))
122
+ metric = str(getattr(self.args, "p_basin_metric", "l1")).lower()
123
+ vecs = [q[mask].detach().clamp(1e-5, 1.0 - 1e-5) for q in qs]
124
+ for i in range(n):
125
+ for j in range(i + 1, n):
126
+ if metric == "l2":
127
+ val = torch.sqrt(((vecs[i] - vecs[j]) ** 2).mean() + 1e-8)
128
+ elif metric == "bce":
129
+ val = -(
130
+ vecs[i] * torch.log(vecs[j])
131
+ + (1.0 - vecs[i]) * torch.log(1.0 - vecs[j])
132
+ + vecs[j] * torch.log(vecs[i])
133
+ + (1.0 - vecs[j]) * torch.log(1.0 - vecs[i])
134
+ ).mean() * 0.5
135
+ else:
136
+ val = torch.abs(vecs[i] - vecs[j]).mean()
137
+ val = torch.nan_to_num(val, nan=0.0, posinf=10.0, neginf=0.0).clamp(0.0, 10.0)
138
+ dist[i, j] = val
139
+ dist[j, i] = val
140
+ return dist
141
+
142
+ def _stage1_p_cluster_mode_assignments(
143
+ self,
144
+ data: Any,
145
+ graph_indices: List[int],
146
+ batch_vec: torch.Tensor,
147
+ graph_feat: torch.Tensor,
148
+ base_idx: int,
149
+ num_modes: int,
150
+ ) -> Tuple[Dict[int, int], int]:
151
+ """Cluster references by Stage-1 probability graphs Q_ref."""
152
+ valid_graphs: List[int] = []
153
+ qs: List[torch.Tensor] = []
154
+ base_mask = batch_vec == int(base_idx)
155
+ edge_i = self.model._get_local_edge_index(data.edge_index, base_mask)
156
+ stage1_kernel = str(getattr(self.args, "stage1_kernel", "umap")).lower()
157
+ graph_feat_i = graph_feat[int(base_idx)].detach()
158
+
159
+ for gi in graph_indices:
160
+ mask = batch_vec == int(gi)
161
+ pos = data.pos[mask]
162
+ if pos.size(0) <= 1:
163
+ continue
164
+ try:
165
+ cidx = self.model._get_conf_idx(data, int(gi))
166
+ a, b = self.model.predict_ab(graph_feat_i, cidx)
167
+ q = prob_low_dim_kernel(
168
+ pos,
169
+ a.detach(),
170
+ b.detach(),
171
+ kernel=stage1_kernel,
172
+ ).clamp(1e-6, 1.0 - 1e-6)
173
+ except Exception:
174
+ logger.exception("Failed to build Q_ref for graph %s", gi)
175
+ continue
176
+ if q.size(0) != pos.size(0):
177
+ continue
178
+ valid_graphs.append(int(gi))
179
+ qs.append(q.detach())
180
+
181
+ n = len(valid_graphs)
182
+ if n == 0:
183
+ return {}, 0
184
+ if n == 1 or int(num_modes) <= 1:
185
+ return {valid_graphs[0]: 0}, 1
186
+
187
+ mean_q = torch.stack(qs, dim=0).mean(dim=0)
188
+ pair_mask = self._pbasin_pair_mask(mean_q, edge_i)
189
+ if int(pair_mask.sum().item()) == 0:
190
+ return self._cluster_mode_assignments(data, graph_indices, batch_vec, num_modes)
191
+
192
+ dist = self._pbasin_distance(qs, pair_mask)
193
+ k_clusters = max(1, min(int(num_modes), n))
194
+ if str(getattr(self.args, "p_basin_anchor_mode", "maxmean")).lower() == "first":
195
+ anchors = [0]
196
+ else:
197
+ anchors = [int(torch.argmax(dist.mean(dim=1)).item())]
198
+ while len(anchors) < k_clusters:
199
+ min_to_anchor = dist[:, anchors].min(dim=1).values
200
+ min_to_anchor[torch.tensor(anchors, device=dist.device, dtype=torch.long)] = -1.0
201
+ anchors.append(int(torch.argmax(min_to_anchor).item()))
202
+
203
+ nearest = torch.argmin(dist[:, anchors], dim=1).detach().cpu().tolist()
204
+ return {valid_graphs[i]: int(nearest[i]) for i in range(n)}, k_clusters
205
+
206
+
207
+ def main(args=None, optuna_trial=None):
208
+ if args is None:
209
+ args = parse_all_args()
210
+ args.train_stage = "multimode"
211
+ if str(getattr(args, "mode_assignment_strategy", "min")).lower() == "min":
212
+ args.mode_assignment_strategy = "stage1_p_basin_window"
213
+ args.deterministic_modes = bool(getattr(args, "deterministic_modes", True))
214
+
215
+ logger.info("=" * 60)
216
+ logger.info("Manimol Stage-2 P-basin bottleneck training")
217
+ logger.info("mode_assignment_strategy = %s", getattr(args, "mode_assignment_strategy", None))
218
+ logger.info("p_basin_metric = %s", getattr(args, "p_basin_metric", None))
219
+ logger.info("p_basin_topk_pairs = %s", getattr(args, "p_basin_topk_pairs", None))
220
+ logger.info("p_basin_min_topo = %s", getattr(args, "p_basin_min_topo", None))
221
+ logger.info("=" * 60)
222
+
223
+ original_trainer = train_torsion_generator.TorsionTrainer
224
+ original_parse_all_args = train_torsion_generator.parse_all_args
225
+ try:
226
+ train_torsion_generator.TorsionTrainer = ProbabilityBasinTrainer
227
+ train_torsion_generator.parse_all_args = lambda: args
228
+ return train_torsion_generator.main(args=args, optuna_trial=optuna_trial)
229
+ finally:
230
+ train_torsion_generator.TorsionTrainer = original_trainer
231
+ train_torsion_generator.parse_all_args = original_parse_all_args
232
+
233
+
234
+ if __name__ == "__main__":
235
+ main()