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,583 @@
1
+ #!/usr/bin/env python3
2
+ """Train mixture latent modes with mode-conditioned torsion flow matching."""
3
+ from __future__ import annotations
4
+
5
+ from _path import ROOT # noqa: F401
6
+
7
+ import argparse
8
+ import os
9
+
10
+ import torch
11
+ import torch.nn.functional as F
12
+ from rdkit import RDLogger
13
+ from rdkit import Chem
14
+ from torch_geometric.loader import DataLoader
15
+ from tqdm import tqdm
16
+
17
+ from dataset import QM9Dataset
18
+ from infer_base_conformers import build_model_args, get_split_indices
19
+ from mixture_torsion_flow import MixtureTorsionFlowModel, circular_distance, normalize_periodic, offdiag_bce
20
+ from models.model0 import (
21
+ GNNEncoder,
22
+ _torsion_rows,
23
+ apply_torsion_residuals,
24
+ pair_distance_match_loss,
25
+ periodic_angle_delta,
26
+ prob_low_dim_kernel,
27
+ torsion_angles,
28
+ )
29
+ from torsion_manifold import probability_graph_torsion_context, probability_graph_torsion_pair_bias
30
+ from infer_torsion import generate_base_conformers
31
+ from trainer import MoleculeGroupedBatchSampler
32
+ from train_torsion_manifold_prior import choose_subset
33
+
34
+ RDLogger.DisableLog("rdApp.*")
35
+
36
+
37
+ # ETKDG is deterministic in this project (seed 42), so caching one scaffold per
38
+ # molecule keeps the residual-flow objective faithful without embedding anew each epoch.
39
+ _SCAFFOLD_CACHE = {}
40
+
41
+
42
+ def parse_args():
43
+ p = argparse.ArgumentParser(description="Mixture latent mode + torsion flow matching")
44
+ p.add_argument("--fixed_dump_name", action="store_true")
45
+ p.add_argument("--data_root", default="data")
46
+ p.add_argument("--dataset", default="Drugs")
47
+ p.add_argument("--raw_prefix", default="geom_drugs")
48
+ p.add_argument("--checkpoint", required=True)
49
+ p.add_argument("--output", required=True)
50
+ p.add_argument("--device", default="cpu")
51
+ p.add_argument("--max_confs", type=int, default=5)
52
+ p.add_argument("--max_torsions", type=int, default=64)
53
+ p.add_argument("--components", type=int, default=8)
54
+ p.add_argument("--mode_dim", type=int, default=64)
55
+ p.add_argument("--hidden_dim", type=int, default=192)
56
+ p.add_argument("--flow_layers", type=int, default=3)
57
+ p.add_argument("--epochs", type=int, default=70)
58
+ p.add_argument("--warmup_epochs", type=int, default=12)
59
+ p.add_argument("--batch_size", type=int, default=18)
60
+ p.add_argument("--num_workers", type=int, default=0)
61
+ p.add_argument("--lr", type=float, default=4e-4)
62
+ p.add_argument("--assign_temperature", type=float, default=0.35)
63
+ p.add_argument("--geo_weight", type=float, default=0.45)
64
+ p.add_argument("--torsion_weight", type=float, default=1.0)
65
+ p.add_argument("--proto_weight", type=float, default=0.35)
66
+ p.add_argument("--balance_weight", type=float, default=0.018)
67
+ p.add_argument("--flow_weight", type=float, default=1.0)
68
+ p.add_argument("--consistency_weight", type=float, default=0.10)
69
+ p.add_argument("--endpoint_torsion_weight", type=float, default=0.35)
70
+ p.add_argument("--endpoint_pair_weight", type=float, default=0.08)
71
+ p.add_argument("--repair_weight", type=float, default=0.35)
72
+ p.add_argument("--repair_supervision_weight", type=float, default=0.0)
73
+ p.add_argument("--repair_step_scale", type=float, default=0.35)
74
+ p.add_argument("--repair_target_max_norm", type=float, default=0.75)
75
+ p.add_argument("--mode_center_alpha_train", type=float, default=0.0)
76
+ p.add_argument("--scaffold_conditioned", action="store_true")
77
+ p.add_argument("--scaffold_method", default="etkdg")
78
+ p.add_argument("--rollout_steps", type=int, default=0)
79
+ p.add_argument("--rollout_repair_steps", type=int, default=1)
80
+ p.add_argument("--rollout_torsion_weight", type=float, default=0.0)
81
+ p.add_argument("--rollout_pair_weight", type=float, default=0.0)
82
+ p.add_argument("--rollout_palign_weight", type=float, default=0.0)
83
+ p.add_argument("--rollout_palign_min_graph_dist", type=int, default=3)
84
+ p.add_argument(
85
+ "--selection_metric",
86
+ choices=["loss", "endpoint_pair", "rollout_pair", "rollout_torsion"],
87
+ default="loss",
88
+ help="Validation quantity used to retain the joint checkpoint.",
89
+ )
90
+ p.add_argument("--limit_train_molecules", type=int, default=200)
91
+ p.add_argument("--limit_valid_molecules", type=int, default=50)
92
+ p.add_argument("--seed", type=int, default=20260725)
93
+ return p.parse_args()
94
+
95
+
96
+ def load_base(path, device):
97
+ cli = argparse.Namespace(
98
+ max_confs=5,
99
+ num_modes=10,
100
+ use_mode_specific_p=False,
101
+ mode_p_delta_scale=1.0,
102
+ deterministic_modes=True,
103
+ use_torsion_residual=False,
104
+ torsion_residual_max=64,
105
+ torsion_residual_scale=1.0,
106
+ )
107
+ model = GNNEncoder(args=build_model_args(cli), config={"model": {"model_level": "graph"}}).to(device)
108
+ state = torch.load(path, map_location=device, weights_only=False)
109
+ model.load_state_dict(state.get("model_state_dict", state.get("state_dict", state)), strict=False)
110
+ model.eval()
111
+ for parameter in model.parameters():
112
+ parameter.requires_grad_(False)
113
+ return model
114
+
115
+
116
+ def prepare_targets(args, positions, rows):
117
+ target = torch.zeros(len(positions), int(args.max_torsions), 2, dtype=positions[0].dtype, device=positions[0].device)
118
+ for idx, pos in enumerate(positions):
119
+ angle = torsion_angles(pos, rows)
120
+ target[idx, : rows.size(0)] = torch.stack([angle.sin(), angle.cos()], dim=-1)
121
+ valid = torch.zeros(int(args.max_torsions), dtype=torch.bool, device=target.device)
122
+ valid[: rows.size(0)] = True
123
+ return target, valid
124
+
125
+
126
+ def periodic_embedding(angle):
127
+ return torch.stack([angle.sin(), angle.cos()], dim=-1)
128
+
129
+
130
+ def periodic_residual(target_angle, base_angle):
131
+ return periodic_embedding(periodic_angle_delta(target_angle, base_angle))
132
+
133
+
134
+ def cached_scaffold(mol, args, device, dtype):
135
+ """Return the same ETKDG scaffold used as the residual-flow coordinate frame."""
136
+ if mol is None:
137
+ return None
138
+ key = (Chem.MolToSmiles(mol, canonical=True), str(args.scaffold_method).lower())
139
+ scaffold = _SCAFFOLD_CACHE.get(key)
140
+ if scaffold is None:
141
+ candidates = generate_base_conformers(mol, 1, args.scaffold_method)
142
+ if not candidates:
143
+ return None
144
+ scaffold = candidates[0].detach().cpu().float()
145
+ _SCAFFOLD_CACHE[key] = scaffold
146
+ return scaffold.to(device=device, dtype=dtype)
147
+
148
+
149
+ def long_range_p_alignment_loss(pred_q, ref_q, edge_index, min_graph_dist=3):
150
+ n = int(pred_q.size(0))
151
+ eye = torch.eye(n, dtype=torch.bool, device=pred_q.device)
152
+ mask = ~eye
153
+ if edge_index is not None and edge_index.numel() > 0:
154
+ dist = torch.full((n, n), n + 1, dtype=torch.long, device=pred_q.device)
155
+ dist[eye] = 0
156
+ edges = edge_index.long().to(pred_q.device)
157
+ valid = (edges[0] >= 0) & (edges[0] < n) & (edges[1] >= 0) & (edges[1] < n)
158
+ edges = edges[:, valid]
159
+ if edges.numel() > 0:
160
+ dist[edges[0], edges[1]] = 1
161
+ dist[edges[1], edges[0]] = 1
162
+ for k in range(n):
163
+ dist = torch.minimum(dist, dist[:, k].view(n, 1) + dist[k, :].view(1, n))
164
+ mask = mask & (dist >= int(min_graph_dist)) & (dist < n + 1)
165
+ if not bool(mask.any().item()):
166
+ mask = ~eye
167
+ return F.binary_cross_entropy(pred_q.clamp(1e-6, 1.0 - 1e-6)[mask], ref_q.clamp(1e-6, 1.0 - 1e-6)[mask])
168
+
169
+
170
+ def group_record(args, base, model, batch, graph_indices, epoch):
171
+ first = int(graph_indices[0])
172
+ atom_mask = batch.batch == first
173
+ positions = [batch.pos[batch.batch == int(index)] for index in graph_indices]
174
+ if len(positions) < 2 or any(pos.size() != positions[0].size() for pos in positions):
175
+ return None
176
+
177
+ with torch.no_grad():
178
+ node = base.gnn(batch)
179
+ graph_all = base.pool(node, batch.batch)
180
+ graph_feat = graph_all[first].detach()
181
+ edge = base._get_local_edge_index(batch.edge_index, atom_mask)
182
+ pair_base, pair_feat = base._predict_P_global(node[atom_mask], edge)
183
+ a, b = base.predict_ab(graph_feat, conf_idx=0)
184
+
185
+ torsion = base._get_local_torsion_index(getattr(batch, "torsion_index", None), atom_mask)
186
+ rows = _torsion_rows(torsion)
187
+ if rows is None or rows.numel() == 0:
188
+ return None
189
+ rows = rows[: int(args.max_torsions)].long()
190
+ valid_rows = (rows >= 0).all(dim=1) & (rows < positions[0].size(0)).all(dim=1)
191
+ rows = rows[valid_rows]
192
+ if rows.numel() == 0:
193
+ return None
194
+
195
+ target, valid = prepare_targets(args, positions, rows)
196
+ logits, p_modes, mode_embed, mu = model.encode(graph_feat, pair_feat.detach(), pair_base.detach())
197
+ weights = torch.softmax(logits, dim=-1)
198
+
199
+ q_targets = [prob_low_dim_kernel(pos, a.detach(), b.detach(), kernel="umap").detach() for pos in positions]
200
+ geo_dist = []
201
+ for q in q_targets:
202
+ geo_dist.append(torch.stack([offdiag_bce(p_modes[m], q) for m in range(model.components)]))
203
+ geo_dist = torch.stack(geo_dist, dim=0)
204
+ torsion_dist = circular_distance(mu, target, valid)
205
+ distance = float(args.geo_weight) * geo_dist + float(args.torsion_weight) * torsion_dist
206
+ assign_logits = F.log_softmax(logits, dim=-1).view(1, -1) - distance / max(1e-4, float(args.assign_temperature))
207
+ gamma = torch.softmax(assign_logits, dim=-1).detach()
208
+
209
+ mode_align = (gamma * distance).sum(dim=-1).mean()
210
+ proto = (gamma * torsion_dist).sum(dim=-1).mean()
211
+ entropy_penalty = (weights * torch.log(weights.clamp_min(1e-8))).sum()
212
+ stage1_loss = mode_align + float(args.proto_weight) * proto + float(args.balance_weight) * entropy_penalty
213
+
214
+ flow_loss = target.sum() * 0.0
215
+ consistency = target.sum() * 0.0
216
+ endpoint_torsion = target.sum() * 0.0
217
+ endpoint_pair = target.sum() * 0.0
218
+ repair_mag = target.sum() * 0.0
219
+ repair_supervision = target.sum() * 0.0
220
+ rollout_torsion = target.sum() * 0.0
221
+ rollout_pair = target.sum() * 0.0
222
+ rollout_palign = target.sum() * 0.0
223
+ if int(epoch) >= int(args.warmup_epochs):
224
+ flow_terms, consist_terms, endpoint_torsion_terms, endpoint_pair_terms, repair_terms, repair_supervision_terms = [], [], [], [], [], []
225
+ rollout_torsion_terms, rollout_pair_terms, rollout_palign_terms = [], [], []
226
+ mode_ids = torch.argmax(gamma, dim=-1)
227
+ local_edge = edge
228
+ atom_x = batch.x[atom_mask] if hasattr(batch, "x") else None
229
+ scaffold = None
230
+ scaffold_angle = None
231
+ scaffold_embed = None
232
+ if bool(getattr(args, "scaffold_conditioned", False)):
233
+ mol = batch.rdmol[first] if hasattr(batch, "rdmol") else None
234
+ scaffold = cached_scaffold(mol, args, positions[0].device, positions[0].dtype)
235
+ if scaffold is None or scaffold.shape != positions[0].shape:
236
+ return None
237
+ scaffold_angle = torsion_angles(scaffold, rows)
238
+ scaffold_embed = periodic_embedding(scaffold_angle)
239
+ for k in range(target.size(0)):
240
+ m = int(mode_ids[k].item())
241
+ x1 = target[k]
242
+ if scaffold_angle is not None:
243
+ target_angle = torch.atan2(x1[: rows.size(0), 0], x1[: rows.size(0), 1])
244
+ x1 = periodic_residual(target_angle, scaffold_angle)
245
+ noise = normalize_periodic(torch.randn_like(x1))
246
+ alpha = min(1.0, max(0.0, float(getattr(args, "mode_center_alpha_train", 0.0))))
247
+ if alpha > 0.0:
248
+ center = mu[m]
249
+ if scaffold_angle is not None:
250
+ center_angle = torch.atan2(center[: rows.size(0), 0], center[: rows.size(0), 1])
251
+ center = periodic_residual(center_angle, scaffold_angle)
252
+ x0 = normalize_periodic(alpha * center.detach() + (1.0 - alpha) * noise)
253
+ else:
254
+ x0 = noise
255
+ t = torch.rand((), device=x1.device, dtype=x1.dtype)
256
+ x_t = normalize_periodic((1.0 - t) * x0 + t * x1)
257
+ mol = batch.rdmol[first] if hasattr(batch, "rdmol") else None
258
+ p_context, _ = probability_graph_torsion_context(p_modes[m], mol, torsion, args.max_torsions)
259
+ p_pair_bias, _ = probability_graph_torsion_pair_bias(p_modes[m], torsion, args.max_torsions)
260
+ mode_mu = mu[m]
261
+ if scaffold_angle is not None:
262
+ mode_angle = torch.atan2(mode_mu[: rows.size(0), 0], mode_mu[: rows.size(0), 1])
263
+ mode_mu = periodic_residual(mode_angle, scaffold_angle)
264
+ v = model.flow(
265
+ x_t[: rows.size(0)],
266
+ t,
267
+ graph_feat.detach(),
268
+ mode_embed[m],
269
+ mode_mu,
270
+ p_context[: rows.size(0)],
271
+ p_pair_bias[: rows.size(0), : rows.size(0)],
272
+ scaffold_torsion=scaffold_embed,
273
+ )
274
+ target_v = (x1 - x0)[: rows.size(0)]
275
+ flow_terms.append((((v - target_v) ** 2).sum(dim=-1) * valid[: rows.size(0)].float()).sum() / valid[: rows.size(0)].float().sum().clamp_min(1.0))
276
+ endpoint = normalize_periodic(x0[: rows.size(0)] + v)
277
+ flow_norm = v.detach().norm(dim=-1, keepdim=True)
278
+ repair_delta = model.repair(
279
+ endpoint,
280
+ graph_feat.detach(),
281
+ mode_embed[m],
282
+ mode_mu,
283
+ p_context[: rows.size(0)],
284
+ p_pair_bias[: rows.size(0), : rows.size(0)],
285
+ flow_norm=flow_norm,
286
+ scaffold_torsion=scaffold_embed,
287
+ )
288
+ repaired = normalize_periodic(endpoint + float(args.repair_step_scale) * repair_delta)
289
+ endpoint_torsion_terms.append(1.0 - (repaired * x1[: rows.size(0)]).sum(dim=-1).clamp(-1.0, 1.0).mean())
290
+ consist_terms.append(1.0 - (repaired * mode_mu[: rows.size(0)]).sum(dim=-1).clamp(-1.0, 1.0).mean())
291
+ repair_terms.append(repair_delta.norm(dim=-1).mean())
292
+ repair_target = (x1[: rows.size(0)] - endpoint).detach() / max(1e-6, float(args.repair_step_scale))
293
+ target_norm = repair_target.norm(dim=-1, keepdim=True).clamp_min(1e-8)
294
+ repair_target = repair_target * torch.clamp(float(args.repair_target_max_norm) / target_norm, max=1.0)
295
+ repair_supervision_terms.append(F.smooth_l1_loss(repair_delta, repair_target))
296
+ base_angle = scaffold_angle if scaffold_angle is not None else torsion_angles(positions[0], rows)
297
+ pred_angle = torch.atan2(repaired[:, 0], repaired[:, 1])
298
+ delta = periodic_angle_delta(pred_angle, base_angle)
299
+ pred_pos = apply_torsion_residuals(
300
+ scaffold if scaffold is not None else positions[0],
301
+ torsion,
302
+ delta,
303
+ local_edge,
304
+ max_torsions=int(args.max_torsions),
305
+ )
306
+ endpoint_pair_terms.append(
307
+ pair_distance_match_loss(
308
+ pred_pos,
309
+ positions[k],
310
+ atom_x=atom_x,
311
+ edge_index=local_edge,
312
+ max_pairs=512,
313
+ min_ref=1.2,
314
+ max_ref=8.0,
315
+ )
316
+ )
317
+ rollout_steps = max(0, int(getattr(args, "rollout_steps", 0)))
318
+ if rollout_steps > 0 and (
319
+ float(getattr(args, "rollout_torsion_weight", 0.0)) > 0.0
320
+ or float(getattr(args, "rollout_pair_weight", 0.0)) > 0.0
321
+ or float(getattr(args, "rollout_palign_weight", 0.0)) > 0.0
322
+ ):
323
+ x_roll = x0[: rows.size(0)]
324
+ last_roll_norm = torch.zeros(rows.size(0), 1, dtype=x_roll.dtype, device=x_roll.device)
325
+ dt = 1.0 / float(rollout_steps)
326
+ for step in range(rollout_steps):
327
+ time = (float(step) + 0.5) / float(rollout_steps)
328
+ v_roll = model.flow(
329
+ x_roll,
330
+ time,
331
+ graph_feat.detach(),
332
+ mode_embed[m],
333
+ mode_mu,
334
+ p_context[: rows.size(0)],
335
+ p_pair_bias[: rows.size(0), : rows.size(0)],
336
+ scaffold_torsion=scaffold_embed,
337
+ )
338
+ x_roll = normalize_periodic(x_roll + dt * v_roll)
339
+ last_roll_norm = v_roll.detach().norm(dim=-1, keepdim=True)
340
+ for _ in range(max(0, int(getattr(args, "rollout_repair_steps", 1)))):
341
+ delta_roll = model.repair(
342
+ x_roll,
343
+ graph_feat.detach(),
344
+ mode_embed[m],
345
+ mode_mu,
346
+ p_context[: rows.size(0)],
347
+ p_pair_bias[: rows.size(0), : rows.size(0)],
348
+ flow_norm=last_roll_norm,
349
+ scaffold_torsion=scaffold_embed,
350
+ )
351
+ x_roll = normalize_periodic(x_roll + float(args.repair_step_scale) * delta_roll)
352
+ rollout_torsion_terms.append(1.0 - (x_roll * x1[: rows.size(0)]).sum(dim=-1).clamp(-1.0, 1.0).mean())
353
+ rollout_angle = torch.atan2(x_roll[:, 0], x_roll[:, 1])
354
+ rollout_delta = periodic_angle_delta(rollout_angle, base_angle)
355
+ rollout_pos = apply_torsion_residuals(
356
+ scaffold if scaffold is not None else positions[0],
357
+ torsion,
358
+ rollout_delta,
359
+ local_edge,
360
+ max_torsions=int(args.max_torsions),
361
+ )
362
+ if float(getattr(args, "rollout_pair_weight", 0.0)) > 0.0:
363
+ rollout_pair_terms.append(
364
+ pair_distance_match_loss(
365
+ rollout_pos,
366
+ positions[k],
367
+ atom_x=atom_x,
368
+ edge_index=local_edge,
369
+ max_pairs=512,
370
+ min_ref=1.2,
371
+ max_ref=8.0,
372
+ )
373
+ )
374
+ if float(getattr(args, "rollout_palign_weight", 0.0)) > 0.0:
375
+ q_rollout = prob_low_dim_kernel(rollout_pos, a.detach(), b.detach(), kernel="umap")
376
+ rollout_palign_terms.append(
377
+ long_range_p_alignment_loss(
378
+ q_rollout,
379
+ q_targets[k],
380
+ local_edge,
381
+ min_graph_dist=int(getattr(args, "rollout_palign_min_graph_dist", 3)),
382
+ )
383
+ )
384
+ if flow_terms:
385
+ flow_loss = torch.stack(flow_terms).mean()
386
+ consistency = torch.stack(consist_terms).mean()
387
+ endpoint_torsion = torch.stack(endpoint_torsion_terms).mean()
388
+ endpoint_pair = torch.stack(endpoint_pair_terms).mean()
389
+ repair_mag = torch.stack(repair_terms).mean()
390
+ repair_supervision = torch.stack(repair_supervision_terms).mean()
391
+ if rollout_torsion_terms:
392
+ rollout_torsion = torch.stack(rollout_torsion_terms).mean()
393
+ if rollout_pair_terms:
394
+ rollout_pair = torch.stack(rollout_pair_terms).mean()
395
+ if rollout_palign_terms:
396
+ rollout_palign = torch.stack(rollout_palign_terms).mean()
397
+
398
+ loss = (
399
+ stage1_loss
400
+ + float(args.flow_weight) * flow_loss
401
+ + float(args.consistency_weight) * consistency
402
+ + float(args.endpoint_torsion_weight) * endpoint_torsion
403
+ + float(args.endpoint_pair_weight) * endpoint_pair
404
+ + float(args.repair_weight) * repair_mag
405
+ + float(args.repair_supervision_weight) * repair_supervision
406
+ + float(args.rollout_torsion_weight) * rollout_torsion
407
+ + float(args.rollout_pair_weight) * rollout_pair
408
+ + float(args.rollout_palign_weight) * rollout_palign
409
+ )
410
+ return loss, {
411
+ "stage1": stage1_loss.detach(),
412
+ "mode_align": mode_align.detach(),
413
+ "proto": proto.detach(),
414
+ "flow": flow_loss.detach(),
415
+ "consistency": consistency.detach(),
416
+ "endpoint_torsion": endpoint_torsion.detach(),
417
+ "endpoint_pair": endpoint_pair.detach(),
418
+ "repair": repair_mag.detach(),
419
+ "repair_supervision": repair_supervision.detach(),
420
+ "rollout_torsion": rollout_torsion.detach(),
421
+ "rollout_pair": rollout_pair.detach(),
422
+ "rollout_palign": rollout_palign.detach(),
423
+ "entropy": (-(weights * torch.log(weights.clamp_min(1e-8))).sum()).detach(),
424
+ "active": (weights > 0.05).float().sum().detach(),
425
+ "torsions": torch.tensor(float(rows.size(0)), device=target.device),
426
+ "best_mode": torsion_dist.min(dim=1).values.mean().detach(),
427
+ "geo": geo_dist.min(dim=1).values.mean().detach(),
428
+ }
429
+
430
+
431
+ def run_epoch(args, base, model, loader, optimizer=None, label="Train", epoch=0):
432
+ training = optimizer is not None
433
+ model.train(training)
434
+ keys = (
435
+ "loss",
436
+ "stage1",
437
+ "mode_align",
438
+ "proto",
439
+ "flow",
440
+ "consistency",
441
+ "endpoint_torsion",
442
+ "endpoint_pair",
443
+ "repair",
444
+ "repair_supervision",
445
+ "rollout_torsion",
446
+ "rollout_pair",
447
+ "rollout_palign",
448
+ "entropy",
449
+ "active",
450
+ "torsions",
451
+ "best_mode",
452
+ "geo",
453
+ )
454
+ total = {key: 0.0 for key in keys}
455
+ count = 0
456
+ for batch in tqdm(loader, desc=label):
457
+ batch = batch.to(args.device)
458
+ groups = {}
459
+ for gi, mol_id in enumerate(batch.mol_id.detach().cpu().tolist()):
460
+ groups.setdefault(int(mol_id), []).append(gi)
461
+ records = [group_record(args, base, model, batch, indices, epoch) for indices in groups.values()]
462
+ records = [item for item in records if item is not None]
463
+ if not records:
464
+ continue
465
+ loss = torch.stack([item[0] for item in records]).mean()
466
+ if training:
467
+ optimizer.zero_grad(set_to_none=True)
468
+ loss.backward()
469
+ torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
470
+ optimizer.step()
471
+ for item_loss, metrics in records:
472
+ total["loss"] += float(item_loss.detach())
473
+ for key, value in metrics.items():
474
+ total[key] += float(value)
475
+ count += len(records)
476
+ return {key: value / max(1, count) for key, value in total.items()}, count
477
+
478
+
479
+ def main():
480
+ args = parse_args()
481
+ torch.manual_seed(args.seed)
482
+ args.device = "cuda" if args.device == "auto" and torch.cuda.is_available() else args.device
483
+ os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
484
+ device = torch.device(args.device)
485
+
486
+ data = QM9Dataset(name=args.dataset, root=args.data_root, max_confs=args.max_confs, raw_prefix=args.raw_prefix)
487
+ train = choose_subset(data, get_split_indices(data, "train"), args.limit_train_molecules)
488
+ valid = choose_subset(data, get_split_indices(data, "valid"), args.limit_valid_molecules)
489
+ train_loader = DataLoader(train, batch_sampler=MoleculeGroupedBatchSampler(train, args.batch_size, shuffle=True), num_workers=args.num_workers)
490
+ valid_loader = DataLoader(valid, batch_sampler=MoleculeGroupedBatchSampler(valid, args.batch_size, shuffle=False), num_workers=args.num_workers)
491
+
492
+ base = load_base(args.checkpoint, device)
493
+ model = MixtureTorsionFlowModel(
494
+ graph_dim=128,
495
+ pair_dim=515,
496
+ components=args.components,
497
+ mode_dim=args.mode_dim,
498
+ max_torsions=args.max_torsions,
499
+ hidden_dim=args.hidden_dim,
500
+ flow_layers=args.flow_layers,
501
+ scaffold_conditioned=bool(args.scaffold_conditioned),
502
+ ).to(device)
503
+ optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-5)
504
+ best_warmup = float("inf")
505
+ best_joint = float("inf")
506
+
507
+ def save_checkpoint(path, valid_stats, epoch, stage):
508
+ torch.save(
509
+ {
510
+ "model_state_dict": model.state_dict(),
511
+ "model_type": "mixture_torsion_flow",
512
+ "graph_dim": 128,
513
+ "pair_dim": 515,
514
+ "components": args.components,
515
+ "mode_dim": args.mode_dim,
516
+ "max_torsions": args.max_torsions,
517
+ "hidden_dim": args.hidden_dim,
518
+ "flow_layers": args.flow_layers,
519
+ "scaffold_conditioned": bool(args.scaffold_conditioned),
520
+ "base_checkpoint": args.checkpoint,
521
+ "epoch": int(epoch),
522
+ "stage": str(stage),
523
+ "valid_loss": float(valid_stats["loss"]),
524
+ "valid_stage1": float(valid_stats["stage1"]),
525
+ "valid_flow": float(valid_stats["flow"]),
526
+ "valid_endpoint_torsion": float(valid_stats["endpoint_torsion"]),
527
+ "valid_endpoint_pair": float(valid_stats["endpoint_pair"]),
528
+ "valid_repair": float(valid_stats["repair"]),
529
+ "valid_repair_supervision": float(valid_stats["repair_supervision"]),
530
+ "valid_rollout_torsion": float(valid_stats["rollout_torsion"]),
531
+ "valid_rollout_pair": float(valid_stats["rollout_pair"]),
532
+ "valid_rollout_palign": float(valid_stats["rollout_palign"]),
533
+ },
534
+ path,
535
+ )
536
+ for epoch in range(args.epochs):
537
+ train_stats, _ = run_epoch(args, base, model, train_loader, optimizer, f"Train E[{epoch}]", epoch)
538
+ with torch.no_grad():
539
+ valid_stats, n_valid = run_epoch(args, base, model, valid_loader, None, f"Valid E[{epoch}]", epoch)
540
+ print(
541
+ "epoch={:03d} train={:.5f} valid={:.5f} stage1={:.5f} align={:.5f} proto={:.5f} flow={:.5f} consist={:.5f} end_tau={:.5f} end_pair={:.5f} repair={:.5f} repair_sup={:.5f} roll_tau={:.5f} roll_pair={:.5f} roll_p={:.5f} best_mode={:.5f} geo={:.5f} entropy={:.3f} active={:.1f} torsions={:.1f} n={}".format(
542
+ epoch,
543
+ train_stats["loss"],
544
+ valid_stats["loss"],
545
+ valid_stats["stage1"],
546
+ valid_stats["mode_align"],
547
+ valid_stats["proto"],
548
+ valid_stats["flow"],
549
+ valid_stats["consistency"],
550
+ valid_stats["endpoint_torsion"],
551
+ valid_stats["endpoint_pair"],
552
+ valid_stats["repair"],
553
+ valid_stats["repair_supervision"],
554
+ valid_stats["rollout_torsion"],
555
+ valid_stats["rollout_pair"],
556
+ valid_stats["rollout_palign"],
557
+ valid_stats["best_mode"],
558
+ valid_stats["geo"],
559
+ valid_stats["entropy"],
560
+ valid_stats["active"],
561
+ valid_stats["torsions"],
562
+ n_valid,
563
+ )
564
+ )
565
+ if epoch < int(args.warmup_epochs):
566
+ if valid_stats["loss"] < best_warmup:
567
+ best_warmup = valid_stats["loss"]
568
+ warmup_path = args.output.replace(".pt", "_warmup.pt") if args.output.endswith(".pt") else args.output + "_warmup.pt"
569
+ save_checkpoint(warmup_path, valid_stats, epoch, "warmup")
570
+ print(f"New best mixture Stage1 warm-up: {best_warmup:.5f}; saved {warmup_path}")
571
+ continue
572
+ selection_metric = float(valid_stats[str(args.selection_metric)])
573
+ if selection_metric < best_joint:
574
+ best_joint = selection_metric
575
+ save_checkpoint(args.output, valid_stats, epoch, "joint")
576
+ print(
577
+ f"New best mixture torsion-flow joint model: "
578
+ f"{args.selection_metric}={best_joint:.5f}; saved {args.output}"
579
+ )
580
+
581
+
582
+ if __name__ == "__main__":
583
+ main()
@@ -0,0 +1,7 @@
1
+ """Compatibility shim for mixture-flow checkpoints and adapters.
2
+
3
+ The implementation lives in mixture_flow/src so the experimental mixture-flow
4
+ line is separated from the current MANIMOL pipeline while old imports still
5
+ resolve for YAML tasks and checkpoint adapters.
6
+ """
7
+ from mixture_flow.src.mixture_torsion_flow import * # noqa: F401,F403
@@ -0,0 +1,86 @@
1
+ import os
2
+ import numpy as np
3
+ from rdkit import Chem
4
+ from rdkit.Chem import AllChem
5
+
6
+ from vis import visualize_and_save_frame
7
+ from render import render_html_to_image
8
+ from constrains import center_and_rescale
9
+ from losses import CE, CE_gradient
10
+ from kernels import (
11
+ KERNEL, UMAPLowKernel, GaussianKernel, StudentTKernel, pairwise_dist,
12
+ UMAPRowExpKernel, UMAPRowFamilyKernel, SmoothKRowExpKernel, find_ab_params,
13
+ )
14
+
15
+ class ManifoldRunner:
16
+ def __init__(self, min_dist=0.9, spread=1.0, seed=42):
17
+ """
18
+ 初始化时选择核函数(默认用 UMAP Low Kernel)。
19
+ """
20
+ self.seed = seed
21
+ a, b = find_ab_params(min_dist=min_dist, spread=spread)
22
+ self.kernel = UMAPLowKernel(a, b)
23
+ self._eps = 1e-12
24
+
25
+ def teacher_coords_from_smiles(self, smiles, optimize=True):
26
+ """
27
+ 用 RDKit ETKDG 生成 3D 坐标(仅重原子,保持与你可视化的原子顺序一致)。
28
+ """
29
+ mol = Chem.MolFromSmiles(smiles)
30
+ mol = Chem.AddHs(mol) # ETKDG 更稳
31
+ params = AllChem.ETKDGv3()
32
+ params.randomSeed = self.seed
33
+ params.useSmallRingTorsions = True
34
+ ok = AllChem.EmbedMolecule(mol, params)
35
+ if ok != 0:
36
+ raise RuntimeError("ETKDG embedding failed.")
37
+ if optimize:
38
+ try:
39
+ AllChem.UFFOptimizeMolecule(mol, maxIters=500)
40
+ except Exception:
41
+ pass
42
+ conf = mol.GetConformer()
43
+ mol_noH = Chem.RemoveHs(mol)
44
+ idx_map = [conf.GetAtomPosition(a.GetIdx()) for a in mol_noH.GetAtoms()]
45
+ Y_true = np.array([[p.x, p.y, p.z] for p in idx_map], dtype=float)
46
+ return mol_noH, Y_true
47
+
48
+ def q_from_Y(self, Y: np.ndarray):
49
+ """
50
+ 给定坐标 Y,计算核矩阵 Q 和距离矩阵 D。
51
+ """
52
+ D = pairwise_dist(Y)
53
+ Q = self.kernel.forward(D)
54
+ return Q, D
55
+
56
+
57
+
58
+ mol, Y_true = teacher_coords_from_smiles(mol, seed=2025, optimize=True)
59
+ Y_true = center_and_rescale(Y_true, target_rms=1.0)
60
+ P, _ = q_from_Y(Y_true) # 这里把“高维 Q*”记为 P(与你原代码接口一致)
61
+
62
+ # 初始化 Y(随机)并规范化
63
+ N = Y_true.shape[0]
64
+ rng = np.random.default_rng(123)
65
+ Y = rng.normal(size=(N, 3))
66
+ Y = center_and_rescale(Y, target_rms=1.0)
67
+
68
+ # 优化配置
69
+ lr = 0.01
70
+ epochs = 1000
71
+
72
+ output_dir = "frames"
73
+ os.makedirs(output_dir, exist_ok=True)
74
+
75
+ CE_array = []
76
+ for i in range(epochs):
77
+ # 梯度 & 更新
78
+ g = CE_gradient(P, Y)
79
+ Y = Y - lr * g
80
+ Y = center_and_rescale(Y, target_rms=1.0)
81
+
82
+ # 记录 CE(用 off-diagonal 的均值)
83
+ CE_mat = CE(P, Y)
84
+ off = ~np.eye(N, dtype=bool)
85
+ CE_current = CE_mat[off].mean()
86
+ CE_array.append(CE_current)
models/__init__.py ADDED
@@ -0,0 +1,8 @@
1
+ from .model0 import GNNEncoder#,EGNNEcoder
2
+ from .kernels import (
3
+ KERNEL, UMAPLowKernel, GaussianKernel, StudentTKernel, pairwise_dist,
4
+ UMAPRowExpKernel, UMAPRowFamilyKernel, SmoothKRowExpKernel, find_ab_params,
5
+ )
6
+ from .kernels import KERNEL, pairwise_dist
7
+ from .dist import compute_AE_tanimoto_distance_np, compute_augmented_graph_distance_np, compute_embed3d_distance_np
8
+ from .dist import hop_matrix_from_mol