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,258 @@
1
+ #!/usr/bin/env python3
2
+ """Train a graph-conditioned mixture prior over observed 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
+ probability_graph_torsion_context,
27
+ )
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("--checkpoint", required=True)
38
+ parser.add_argument("--output", required=True)
39
+ parser.add_argument("--device", default="cpu")
40
+ parser.add_argument("--max_confs", type=int, default=5,
41
+ help="Stage-I capacity; 0 reads it from --checkpoint.")
42
+ parser.add_argument("--max_torsions", type=int, default=64)
43
+ parser.add_argument("--components", type=int, default=8)
44
+ parser.add_argument("--hidden_dim", type=int, default=160)
45
+ parser.add_argument("--concentration", type=float, default=12.0)
46
+ parser.add_argument("--entropy_weight", type=float, default=0.015)
47
+ parser.add_argument(
48
+ "--set_affinity_alignment",
49
+ action="store_true",
50
+ help="Align mixture-mode co-assignments to a UMAP-kernel teacher graph over reference torsion states.",
51
+ )
52
+ parser.add_argument("--set_affinity_weight", type=float, default=0.20)
53
+ parser.add_argument(
54
+ "--probability_graph_aligned",
55
+ action="store_true",
56
+ help="Condition torsion prototypes on Stage-1 P cross-fragment constraints.",
57
+ )
58
+ parser.add_argument("--epochs", type=int, default=60)
59
+ parser.add_argument("--lr", type=float, default=5e-4)
60
+ parser.add_argument("--batch_size", type=int, default=24)
61
+ parser.add_argument("--num_workers", type=int, default=0)
62
+ parser.add_argument("--limit_train_molecules", type=int, default=200)
63
+ parser.add_argument("--limit_valid_molecules", type=int, default=50)
64
+ parser.add_argument("--seed", type=int, default=20260721)
65
+ return parser.parse_args()
66
+
67
+
68
+ def choose_subset(dataset, indices, limit):
69
+ seen, keep = set(), []
70
+ for index in indices.tolist() if hasattr(indices, "tolist") else indices:
71
+ molecule_id = int(dataset[int(index)].mol_id.item())
72
+ if molecule_id not in seen and int(limit) > 0 and len(seen) >= int(limit):
73
+ continue
74
+ seen.add(molecule_id)
75
+ keep.append(int(index))
76
+ return dataset[keep]
77
+
78
+
79
+ def load_base(path, device):
80
+ cli = argparse.Namespace(
81
+ max_confs=5, num_modes=10, use_mode_specific_p=False,
82
+ mode_p_delta_scale=1.0, deterministic_modes=True,
83
+ use_torsion_residual=False, torsion_residual_max=64,
84
+ torsion_residual_scale=1.0,
85
+ )
86
+ model = GNNEncoder(args=build_model_args(cli), config={"model": {"model_level": "graph"}}).to(device)
87
+ state = torch.load(path, map_location=device, weights_only=False)
88
+ model.load_state_dict(state.get("model_state_dict", state.get("state_dict", state)), strict=False)
89
+ model.eval()
90
+ for parameter in model.parameters():
91
+ parameter.requires_grad_(False)
92
+ return model
93
+
94
+
95
+ def torsion_affinity_teacher(target, valid_mask, a, b):
96
+ """UMAP affinity graph over the observed torsion-state ensemble.
97
+
98
+ Nodes are conformers of one molecule rather than atoms. The frozen
99
+ Stage-1 kernel supplies molecule-adaptive positive ``a`` and ``b``;
100
+ torsion distances make the teacher periodic and chemically meaningful.
101
+ """
102
+ vectors = target[:, valid_mask]
103
+ if vectors.size(0) < 2 or vectors.size(1) == 0:
104
+ return None
105
+ cosine = torch.einsum("mtd,ntd->mnt", vectors, vectors).clamp(-1.0, 1.0)
106
+ distance = (1.0 - cosine).mean(dim=-1)
107
+ a = torch.as_tensor(a, dtype=distance.dtype, device=distance.device).reshape(()).abs().clamp_min(1e-5)
108
+ b = torch.as_tensor(b, dtype=distance.dtype, device=distance.device).reshape(()).abs().clamp_min(1e-5)
109
+ return 1.0 / (1.0 + a * distance.clamp_min(1e-8).pow(2.0 * b))
110
+
111
+
112
+ def set_affinity_alignment(distance, logits, target, valid_mask, a, b):
113
+ """Teacher-student agreement between reference and mode affinity graphs."""
114
+ teacher = torsion_affinity_teacher(target, valid_mask, a, b)
115
+ if teacher is None:
116
+ zero = distance.sum() * 0.0
117
+ return zero, zero, zero
118
+ assignments = torch.softmax(F.log_softmax(logits, dim=-1).view(1, -1) - distance, dim=-1)
119
+ student = (assignments @ assignments.transpose(0, 1)).clamp(1e-5, 1.0 - 1e-5)
120
+ off_diagonal = ~torch.eye(student.size(0), dtype=torch.bool, device=student.device)
121
+ if not off_diagonal.any():
122
+ zero = distance.sum() * 0.0
123
+ return zero, zero, zero
124
+ loss = F.binary_cross_entropy(student[off_diagonal], teacher.detach()[off_diagonal])
125
+ baseline_value = teacher[off_diagonal].mean().clamp(1e-5, 1.0 - 1e-5)
126
+ baseline = F.binary_cross_entropy(torch.full_like(teacher[off_diagonal], baseline_value), teacher.detach()[off_diagonal])
127
+ return loss, teacher[off_diagonal].mean(), baseline
128
+
129
+
130
+ def group_record(args, base, prior, batch, graph_indices):
131
+ first = int(graph_indices[0])
132
+ atom_mask = batch.batch == first
133
+ positions = [batch.pos[batch.batch == int(index)] for index in graph_indices]
134
+ if len(positions) < 2 or any(position.size() != positions[0].size() for position in positions):
135
+ return None
136
+ with torch.no_grad():
137
+ node = base.gnn(batch)
138
+ graph = base.pool(node, batch.batch)[first].detach()
139
+ torsion = base._get_local_torsion_index(getattr(batch, "torsion_index", None), atom_mask)
140
+ rows = _torsion_rows(torsion)
141
+ if rows is None or rows.numel() == 0:
142
+ return None
143
+ rows = rows[: int(args.max_torsions)].long()
144
+ valid = (rows >= 0).all(dim=1) & (rows < positions[0].size(0)).all(dim=1)
145
+ rows = rows[valid]
146
+ if rows.numel() == 0:
147
+ return None
148
+ target = torch.zeros(len(positions), int(args.max_torsions), 2, device=positions[0].device)
149
+ for index, position in enumerate(positions):
150
+ angles = torsion_angles(position, rows)
151
+ target[index, : rows.size(0)] = torch.stack([angles.sin(), angles.cos()], dim=-1)
152
+ valid_mask = torch.zeros(int(args.max_torsions), dtype=torch.bool, device=target.device)
153
+ valid_mask[: rows.size(0)] = True
154
+ if bool(args.probability_graph_aligned):
155
+ edge = base._get_local_edge_index(batch.edge_index, atom_mask)
156
+ with torch.no_grad():
157
+ P, _ = base._predict_P_global(node[atom_mask], edge)
158
+ mol = batch.rdmol[first] if hasattr(batch, "rdmol") else None
159
+ p_context, _ = probability_graph_torsion_context(P, mol, torsion, args.max_torsions)
160
+ logits, prototypes = prior(graph, p_context)
161
+ else:
162
+ logits, prototypes = prior(graph)
163
+ nll, distance = mixture_torsion_nll(logits, prototypes, target, valid_mask, args.concentration)
164
+ weights = torch.softmax(logits, dim=-1)
165
+ entropy_penalty = (weights * torch.log(weights.clamp_min(1e-8))).sum()
166
+ affinity_loss = target.sum() * 0.0
167
+ affinity_mean = target.sum() * 0.0
168
+ affinity_baseline = target.sum() * 0.0
169
+ if bool(args.set_affinity_alignment):
170
+ with torch.no_grad():
171
+ a, b = base.predict_ab(graph, conf_idx=0)
172
+ affinity_loss, affinity_mean, affinity_baseline = set_affinity_alignment(
173
+ distance, logits, target, valid_mask, a, b
174
+ )
175
+ loss = nll + float(args.entropy_weight) * entropy_penalty + float(args.set_affinity_weight) * affinity_loss
176
+ return loss, {
177
+ "nll": nll.detach(),
178
+ "best_torsion": distance.min(dim=1).values.mean().detach(),
179
+ "entropy": (-(weights * torch.log(weights.clamp_min(1e-8))).sum()).detach(),
180
+ "torsions": torch.tensor(float(rows.size(0)), device=target.device),
181
+ "affinity": affinity_loss.detach(),
182
+ "affinity_mean": affinity_mean.detach(),
183
+ "affinity_baseline": affinity_baseline.detach(),
184
+ }
185
+
186
+
187
+ def run_epoch(args, base, prior, loader, optimizer=None, label="Train"):
188
+ training = optimizer is not None
189
+ prior.train(training)
190
+ totals = {key: 0.0 for key in ("loss", "nll", "best_torsion", "entropy", "torsions", "affinity", "affinity_mean", "affinity_baseline")}
191
+ count = 0
192
+ for batch in tqdm(loader, desc=label):
193
+ batch = batch.to(args.device)
194
+ groups = {}
195
+ for graph_index, molecule_id in enumerate(batch.mol_id.detach().cpu().tolist()):
196
+ groups.setdefault(int(molecule_id), []).append(graph_index)
197
+ records = [group_record(args, base, prior, batch, indices) for indices in groups.values()]
198
+ records = [record for record in records if record is not None]
199
+ if not records:
200
+ continue
201
+ loss = torch.stack([record[0] for record in records]).mean()
202
+ if training:
203
+ optimizer.zero_grad(set_to_none=True)
204
+ loss.backward()
205
+ torch.nn.utils.clip_grad_norm_(prior.parameters(), 3.0)
206
+ optimizer.step()
207
+ for record_loss, metrics in records:
208
+ totals["loss"] += float(record_loss.detach())
209
+ for key, value in metrics.items():
210
+ totals[key] += float(value)
211
+ count += len(records)
212
+ return {key: value / max(1, count) for key, value in totals.items()}
213
+
214
+
215
+ def main():
216
+ args = parse_args()
217
+ if int(args.max_confs) == 0:
218
+ args.max_confs = checkpoint_max_confs(args.checkpoint)
219
+ print(f"Auto-resolved max_confs={args.max_confs} from base checkpoint.")
220
+ torch.manual_seed(args.seed)
221
+ args.device = "cuda" if args.device == "auto" and torch.cuda.is_available() else args.device
222
+ device = torch.device(args.device)
223
+ os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
224
+ dataset = QM9Dataset(name=args.dataset, root=args.data_root, max_confs=args.max_confs, raw_prefix=args.raw_prefix)
225
+ train_set = choose_subset(dataset, get_split_indices(dataset, "train"), args.limit_train_molecules)
226
+ valid_set = choose_subset(dataset, get_split_indices(dataset, "valid"), args.limit_valid_molecules)
227
+ train_loader = DataLoader(train_set, batch_sampler=MoleculeGroupedBatchSampler(train_set, args.batch_size, shuffle=True), num_workers=args.num_workers)
228
+ valid_loader = DataLoader(valid_set, batch_sampler=MoleculeGroupedBatchSampler(valid_set, args.batch_size, shuffle=False), num_workers=args.num_workers)
229
+ base = load_base(args.checkpoint, device)
230
+ prior_cls = ProbabilityAlignedTorsionStateMixturePrior if args.probability_graph_aligned else TorsionStateMixturePrior
231
+ prior = prior_cls(128, args.max_torsions, args.components, args.hidden_dim).to(device)
232
+ optimizer = torch.optim.AdamW(prior.parameters(), lr=args.lr, weight_decay=1e-4)
233
+ best = float("inf")
234
+ for epoch in range(args.epochs):
235
+ train = run_epoch(args, base, prior, train_loader, optimizer, f"Train E[{epoch}]")
236
+ with torch.no_grad():
237
+ valid = run_epoch(args, base, prior, valid_loader, None, f"Valid E[{epoch}]")
238
+ print(
239
+ "epoch={:03d} train={:.5f} valid={:.5f} torsion_nll={:.5f} prior_best_torsion={:.5f} affinity={:.5f} affinity_base={:.5f} affinity_mean={:.4f} entropy={:.4f} active_torsions={:.1f}".format(
240
+ epoch, train["loss"], valid["loss"], valid["nll"], valid["best_torsion"], valid["affinity"], valid["affinity_baseline"], valid["affinity_mean"], valid["entropy"], valid["torsions"]
241
+ )
242
+ )
243
+ if valid["loss"] < best:
244
+ best = valid["loss"]
245
+ torch.save({
246
+ "model_state_dict": prior.state_dict(), "graph_dim": 128,
247
+ "max_torsions": args.max_torsions, "components": args.components,
248
+ "hidden_dim": args.hidden_dim, "concentration": args.concentration,
249
+ "prior_type": "p_aligned_torsion_mixture" if args.probability_graph_aligned else "torsion_mixture",
250
+ "context_dim": 4 if args.probability_graph_aligned else 0,
251
+ "set_affinity_alignment": bool(args.set_affinity_alignment),
252
+ "set_affinity_weight": float(args.set_affinity_weight),
253
+ }, args.output)
254
+ print(f"New best torsion manifold prior: {best:.5f}")
255
+
256
+
257
+ if __name__ == "__main__":
258
+ main()
@@ -0,0 +1,415 @@
1
+ #!/usr/bin/env python3
2
+ """Noise-conditioned torsion denoising experiment.
3
+
4
+ This is an isolated Stage-2 branch. It keeps the Manimol GNN / probability
5
+ encoder checkpoint as a frozen molecular representation, but trains a small
6
+ noise-conditioned torsion denoiser:
7
+
8
+ clean conformer -> add torsion noise -> denoiser predicts reverse torsion
9
+
10
+ The goal is to replace one-shot torsion regression with a lightweight
11
+ diffusion-style refinement loop that can better hit tight RMSD basins.
12
+ """
13
+
14
+ from __future__ import annotations
15
+
16
+ import argparse
17
+ import math
18
+ import os
19
+ from typing import Optional
20
+
21
+ import torch
22
+ import torch.nn as nn
23
+ import torch.nn.functional as F
24
+ from torch_geometric.loader import DataLoader
25
+ from tqdm import tqdm
26
+
27
+ from dataset import QM9Dataset
28
+ from infer_base_conformers import build_model_args, checkpoint_max_confs, get_split_indices
29
+ from models.model0 import (
30
+ GNNEncoder,
31
+ _torsion_rows,
32
+ apply_torsion_residuals,
33
+ heavy_atom_mask_from_x,
34
+ periodic_angle_delta,
35
+ safe_heavy_kabsch_rmsd,
36
+ torsion_angles,
37
+ )
38
+ from models.mean_dispersion_torsion_context import dispersion_torsion_widths
39
+
40
+
41
+ class NoiseTorsionDenoiser(nn.Module):
42
+ def __init__(
43
+ self,
44
+ emb_dim=128,
45
+ hidden_dim=128,
46
+ max_delta=0.8,
47
+ backbone: str = "mlp",
48
+ transformer_layers: int = 2,
49
+ transformer_heads: int = 4,
50
+ dropout: float = 0.0,
51
+ ):
52
+ super().__init__()
53
+ self.max_delta = float(max_delta)
54
+ self.backbone = str(backbone).lower()
55
+ # 4 atom embeddings + graph embedding + sin/cos/current + Pjk + 3-d noise embedding.
56
+ in_dim = 5 * int(emb_dim) + 6
57
+ if self.backbone == "transformer":
58
+ self.input_proj = nn.Linear(in_dim, int(hidden_dim))
59
+ layer = nn.TransformerEncoderLayer(
60
+ d_model=int(hidden_dim),
61
+ nhead=int(transformer_heads),
62
+ dim_feedforward=max(int(hidden_dim) * 4, 128),
63
+ dropout=float(dropout),
64
+ activation="gelu",
65
+ batch_first=True,
66
+ norm_first=True,
67
+ )
68
+ self.encoder = nn.TransformerEncoder(layer, num_layers=int(transformer_layers))
69
+ self.out = nn.Sequential(nn.LayerNorm(int(hidden_dim)), nn.Linear(int(hidden_dim), 1))
70
+ else:
71
+ self.net = nn.Sequential(
72
+ nn.Linear(in_dim, int(hidden_dim)),
73
+ nn.SiLU(),
74
+ nn.Linear(int(hidden_dim), int(hidden_dim)),
75
+ nn.SiLU(),
76
+ nn.Linear(int(hidden_dim), 1),
77
+ )
78
+
79
+ def forward(
80
+ self,
81
+ node_feat,
82
+ graph_feat,
83
+ coords,
84
+ P,
85
+ torsion_index,
86
+ sigma,
87
+ max_torsions=64,
88
+ ):
89
+ rows = _torsion_rows(torsion_index)
90
+ if rows is None:
91
+ return coords.new_zeros((0,))
92
+ rows = rows[: min(int(max_torsions), rows.size(0))].to(coords.device).long()
93
+ valid = (rows >= 0).all(dim=1) & (rows < coords.size(0)).all(dim=1)
94
+ rows = rows[valid]
95
+ if rows.numel() == 0:
96
+ return coords.new_zeros((0,))
97
+ current = torsion_angles(coords, rows)
98
+ graph_context = graph_feat.to(coords.device, node_feat.dtype).view(-1)
99
+ sigma_t = torch.as_tensor(float(sigma), device=coords.device, dtype=node_feat.dtype)
100
+ sigma_feat = torch.stack(
101
+ [
102
+ sigma_t,
103
+ torch.sin(sigma_t * math.pi),
104
+ torch.cos(sigma_t * math.pi),
105
+ ]
106
+ )
107
+ feats = []
108
+ for idx, row in enumerate(rows):
109
+ i, j, k, l = row
110
+ feats.append(
111
+ torch.cat(
112
+ [
113
+ node_feat[i],
114
+ node_feat[j],
115
+ node_feat[k],
116
+ node_feat[l],
117
+ graph_context,
118
+ torch.sin(current[idx]).view(1),
119
+ torch.cos(current[idx]).view(1),
120
+ P[j, k].view(1),
121
+ sigma_feat,
122
+ ],
123
+ dim=0,
124
+ )
125
+ )
126
+ x = torch.stack(feats, dim=0)
127
+ if self.backbone == "transformer":
128
+ h = self.input_proj(x).unsqueeze(0)
129
+ h = self.encoder(h).squeeze(0)
130
+ raw = self.out(h).view(-1)
131
+ else:
132
+ raw = self.net(x).view(-1)
133
+ return torch.tanh(raw) * self.max_delta
134
+
135
+
136
+ def parse_args():
137
+ p = argparse.ArgumentParser(description="Train noise-conditioned torsion denoiser")
138
+ p.add_argument("--fixed_dump_name", action="store_true")
139
+ p.add_argument("--data_root", type=str, default="data")
140
+ p.add_argument("--dataset", type=str, default="Drugs")
141
+ p.add_argument("--raw_prefix", type=str, default="geom_drugs")
142
+ p.add_argument("--checkpoint", type=str, required=True)
143
+ p.add_argument("--output_dir", type=str, default="dump/drugs_torsion_denoise_limit")
144
+ p.add_argument("--device", type=str, default="cpu")
145
+ p.add_argument("--max_confs", type=int, default=5,
146
+ help="Stage-I capacity; 0 reads it from --checkpoint.")
147
+ p.add_argument("--epochs", type=int, default=40)
148
+ p.add_argument("--patience", type=int, default=0,
149
+ help="Stop after this many validation epochs without improvement; 0 disables early stopping.")
150
+ p.add_argument("--min_delta", type=float, default=0.0,
151
+ help="Minimum validation-loss decrease counted as an improvement.")
152
+ p.add_argument("--batch_size", type=int, default=16)
153
+ p.add_argument("--num_workers", type=int, default=0)
154
+ p.add_argument("--lr", type=float, default=8e-4)
155
+ p.add_argument("--hidden_dim", type=int, default=128)
156
+ p.add_argument("--denoiser_backbone", type=str, default="mlp", choices=["mlp", "transformer"])
157
+ p.add_argument("--transformer_layers", type=int, default=2)
158
+ p.add_argument("--transformer_heads", type=int, default=4)
159
+ p.add_argument("--transformer_dropout", type=float, default=0.0)
160
+ p.add_argument("--max_delta", type=float, default=0.8)
161
+ p.add_argument("--torsion_mode_max", type=int, default=64)
162
+ p.add_argument(
163
+ "--use_dispersion_proposal",
164
+ action="store_true",
165
+ help="Use Stage-I P_disp to modulate torsion-noise and residual widths.",
166
+ )
167
+ p.add_argument("--dispersion_width_scale", type=float, default=0.35)
168
+ p.add_argument("--dispersion_width_min", type=float, default=0.5)
169
+ p.add_argument("--dispersion_width_max", type=float, default=2.0)
170
+ p.add_argument("--limit_train_molecules", type=int, default=0)
171
+ p.add_argument("--limit_valid_molecules", type=int, default=0)
172
+ p.add_argument("--noise_min", type=float, default=0.05)
173
+ p.add_argument("--noise_max", type=float, default=0.75)
174
+ p.add_argument("--lambda_rmsd", type=float, default=1.0)
175
+ p.add_argument("--lambda_torsion", type=float, default=0.5)
176
+ p.add_argument("--lambda_tight", type=float, default=0.5)
177
+ p.add_argument("--tight_threshold", type=float, default=0.75)
178
+ p.add_argument("--seed", type=int, default=0)
179
+ return p.parse_args()
180
+
181
+
182
+ def load_base_model(args, device):
183
+ cli = argparse.Namespace(max_confs=args.max_confs, num_modes=10)
184
+ model_args = build_model_args(cli)
185
+ model = GNNEncoder(args=model_args, config={"model": {"model_level": "graph"}}).to(device)
186
+ ckpt = torch.load(args.checkpoint, map_location=device)
187
+ state = ckpt.get("model_state_dict", ckpt.get("state_dict", ckpt)) if isinstance(ckpt, dict) else ckpt
188
+ missing, unexpected = model.load_state_dict(state, strict=False)
189
+ if missing:
190
+ print(f"Missing base keys ({len(missing)}): {missing[:5]}...")
191
+ if unexpected:
192
+ print(f"Unexpected base keys ({len(unexpected)}): {unexpected[:5]}...")
193
+ model.eval()
194
+ for param in model.parameters():
195
+ param.requires_grad_(False)
196
+ return model
197
+
198
+
199
+ def local_torsion_index(model, batch, graph_idx):
200
+ mask = batch.batch == graph_idx
201
+ return model._get_local_torsion_index(getattr(batch, "torsion_index", None), mask)
202
+
203
+
204
+ def graph_forward(base_model, batch, graph_idx):
205
+ with torch.no_grad():
206
+ node_feat = base_model.gnn(batch)
207
+ graph_feat = base_model.pool(node_feat, batch.batch)
208
+ mask = batch.batch == graph_idx
209
+ feat_i = node_feat[mask]
210
+ edge_i = base_model._get_local_edge_index(batch.edge_index, mask)
211
+ P, P_disp, _ = base_model._predict_mean_dispersion(feat_i, edge_i)
212
+ return feat_i.detach(), graph_feat[graph_idx].detach(), edge_i, P.detach(), P_disp.detach(), mask
213
+
214
+
215
+ def noised_conformer(clean, torsion_index, edge_index, sigma, max_torsions, torsion_scales=None):
216
+ rows = _torsion_rows(torsion_index)
217
+ if rows is None:
218
+ return clean, clean.new_zeros((0,))
219
+ rows = rows[: min(int(max_torsions), rows.size(0))].to(clean.device).long()
220
+ if rows.numel() == 0:
221
+ return clean, clean.new_zeros((0,))
222
+ noise = torch.randn(rows.size(0), device=clean.device, dtype=clean.dtype) * float(sigma)
223
+ if torsion_scales is not None:
224
+ noise = noise * torsion_scales[: noise.size(0)].to(device=noise.device, dtype=noise.dtype)
225
+ noisy = apply_torsion_residuals(clean, rows, noise, edge_index=edge_index, max_torsions=int(max_torsions))
226
+ return noisy, noise
227
+
228
+
229
+ def batch_loss(args, base_model, denoiser, batch, train=True):
230
+ total = batch.pos.new_tensor(0.0)
231
+ valid = 0
232
+ for graph_idx in range(batch.num_graphs):
233
+ mask = batch.batch == graph_idx
234
+ clean = batch.pos[mask]
235
+ if clean.size(0) <= 1:
236
+ continue
237
+ torsion_index = local_torsion_index(base_model, batch, graph_idx)
238
+ rows = _torsion_rows(torsion_index)
239
+ if rows is None or rows.numel() == 0:
240
+ continue
241
+ feat_i, graph_feat_i, edge_i, P, P_disp, _ = graph_forward(base_model, batch, graph_idx)
242
+ if bool(getattr(args, "use_dispersion_proposal", False)):
243
+ torsion_widths, _, _ = dispersion_torsion_widths(
244
+ P_disp,
245
+ batch.rdmol[graph_idx] if hasattr(batch, "rdmol") else None,
246
+ torsion_index,
247
+ int(args.torsion_mode_max),
248
+ scale=float(getattr(args, "dispersion_width_scale", 0.35)),
249
+ min_width=float(getattr(args, "dispersion_width_min", 0.5)),
250
+ max_width=float(getattr(args, "dispersion_width_max", 2.0)),
251
+ )
252
+ else:
253
+ torsion_widths = torch.ones(int(args.torsion_mode_max), device=clean.device, dtype=clean.dtype)
254
+ sigma = float(torch.empty((), device=clean.device).uniform_(float(args.noise_min), float(args.noise_max)).item())
255
+ noisy, _ = noised_conformer(
256
+ clean, torsion_index, edge_i, sigma, int(args.torsion_mode_max), torsion_scales=torsion_widths
257
+ )
258
+ delta = denoiser(
259
+ node_feat=feat_i,
260
+ graph_feat=graph_feat_i,
261
+ coords=noisy,
262
+ P=P,
263
+ torsion_index=torsion_index,
264
+ sigma=sigma,
265
+ max_torsions=int(args.torsion_mode_max),
266
+ )
267
+ applied_delta = delta * torsion_widths[: delta.size(0)]
268
+ pred = apply_torsion_residuals(noisy, torsion_index, applied_delta, edge_index=edge_i, max_torsions=int(args.torsion_mode_max))
269
+ atom_x = batch.x[mask] if hasattr(batch, "x") else None
270
+ rmsd = safe_heavy_kabsch_rmsd(pred, clean, atom_x).clamp(0.0, 10.0)
271
+
272
+ rows = rows[: min(rows.size(0), delta.size(0))].to(clean.device).long()
273
+ current_t = torsion_angles(noisy, rows)
274
+ clean_t = torsion_angles(clean, rows).detach()
275
+ target_delta = periodic_angle_delta(clean_t, current_t)
276
+ torsion_loss = (1.0 - torch.cos(applied_delta[: rows.size(0)] - target_delta)).mean().clamp(0.0, 10.0)
277
+ tight = torch.relu(rmsd - rmsd.new_tensor(float(args.tight_threshold)))
278
+ total = total + float(args.lambda_rmsd) * rmsd + float(args.lambda_torsion) * torsion_loss + float(args.lambda_tight) * tight * tight
279
+ valid += 1
280
+ if valid == 0:
281
+ return batch.pos.sum() * 0.0, 0, 0.0
282
+ return total / valid, valid, float(total.detach().cpu().item()) / valid
283
+
284
+
285
+ def run_epoch(args, base_model, denoiser, loader, opt=None, limit_molecules=0, desc="train"):
286
+ train = opt is not None
287
+ denoiser.train(train)
288
+ total_loss = 0.0
289
+ total_valid = 0
290
+ seen = set()
291
+ for batch in tqdm(loader, desc=desc):
292
+ batch = batch.to(args.device)
293
+ if int(limit_molecules) > 0:
294
+ keep = False
295
+ for gi in range(batch.num_graphs):
296
+ mol_id = int(batch.mol_id[gi].item())
297
+ if mol_id not in seen and len(seen) < int(limit_molecules):
298
+ keep = True
299
+ seen.add(mol_id)
300
+ if not keep:
301
+ if len(seen) >= int(limit_molecules):
302
+ break
303
+ continue
304
+ loss, valid, loss_value = batch_loss(args, base_model, denoiser, batch, train=train)
305
+ if valid == 0:
306
+ continue
307
+ if train:
308
+ opt.zero_grad(set_to_none=True)
309
+ loss.backward()
310
+ torch.nn.utils.clip_grad_norm_(denoiser.parameters(), 3.0)
311
+ opt.step()
312
+ total_loss += loss_value * valid
313
+ total_valid += valid
314
+ return total_loss / max(1, total_valid), total_valid
315
+
316
+
317
+ def main():
318
+ args = parse_args()
319
+ if int(args.max_confs) == 0:
320
+ args.max_confs = checkpoint_max_confs(args.checkpoint)
321
+ print(f"Auto-resolved max_confs={args.max_confs} from base checkpoint.")
322
+ torch.manual_seed(int(args.seed))
323
+ args.device = str(args.device)
324
+ device = torch.device(args.device)
325
+ dataset = QM9Dataset(name=args.dataset, root=args.data_root, max_confs=args.max_confs, raw_prefix=args.raw_prefix)
326
+ train_subset = dataset[get_split_indices(dataset, "train")]
327
+ valid_subset = dataset[get_split_indices(dataset, "valid")]
328
+ train_loader = DataLoader(
329
+ train_subset,
330
+ batch_size=int(args.batch_size),
331
+ shuffle=True,
332
+ num_workers=int(args.num_workers),
333
+ )
334
+ valid_loader = DataLoader(
335
+ valid_subset,
336
+ batch_size=int(args.batch_size),
337
+ shuffle=False,
338
+ num_workers=int(args.num_workers),
339
+ )
340
+
341
+ base_model = load_base_model(args, device)
342
+ denoiser = NoiseTorsionDenoiser(
343
+ hidden_dim=int(args.hidden_dim),
344
+ max_delta=float(args.max_delta),
345
+ backbone=str(args.denoiser_backbone),
346
+ transformer_layers=int(args.transformer_layers),
347
+ transformer_heads=int(args.transformer_heads),
348
+ dropout=float(args.transformer_dropout),
349
+ ).to(device)
350
+ opt = torch.optim.AdamW(denoiser.parameters(), lr=float(args.lr), weight_decay=1e-4)
351
+ os.makedirs(args.output_dir, exist_ok=True)
352
+
353
+ best = float("inf")
354
+ best_state = None
355
+ best_epoch = -1
356
+ epochs_without_improvement = 0
357
+ for epoch in range(int(args.epochs)):
358
+ tr, tr_valid = run_epoch(
359
+ args, base_model, denoiser, train_loader, opt=opt,
360
+ limit_molecules=int(args.limit_train_molecules), desc=f"Train E[{epoch}]",
361
+ )
362
+ va, va_valid = run_epoch(
363
+ args, base_model, denoiser, valid_loader, opt=None,
364
+ limit_molecules=int(args.limit_valid_molecules), desc=f"Valid E[{epoch}]",
365
+ )
366
+ print(f"epoch={epoch:03d} train_loss={tr:.5f} train_valid={tr_valid} valid_loss={va:.5f} valid_valid={va_valid}")
367
+ if va < best - float(args.min_delta):
368
+ best = va
369
+ best_epoch = epoch
370
+ epochs_without_improvement = 0
371
+ best_state = {k: v.detach().cpu().clone() for k, v in denoiser.state_dict().items()}
372
+ torch.save(
373
+ {
374
+ "model_state_dict": best_state,
375
+ "hidden_dim": int(args.hidden_dim),
376
+ "max_delta": float(args.max_delta),
377
+ "denoiser_backbone": str(args.denoiser_backbone),
378
+ "transformer_layers": int(args.transformer_layers),
379
+ "transformer_heads": int(args.transformer_heads),
380
+ "transformer_dropout": float(args.transformer_dropout),
381
+ "torsion_mode_max": int(args.torsion_mode_max),
382
+ "source_checkpoint": args.checkpoint,
383
+ "epoch": int(epoch),
384
+ "best_valid_loss": float(best),
385
+ },
386
+ os.path.join(args.output_dir, "best.pth"),
387
+ )
388
+ print(f"New best valid {best:.5f}; saved {os.path.join(args.output_dir, 'best.pth')}")
389
+ else:
390
+ epochs_without_improvement += 1
391
+ if int(args.patience) > 0 and epochs_without_improvement >= int(args.patience):
392
+ print(
393
+ f"Early stopping at epoch={epoch:03d}; best_epoch={best_epoch:03d} "
394
+ f"best_valid_loss={best:.5f}"
395
+ )
396
+ break
397
+ if best_state is None:
398
+ torch.save(
399
+ {
400
+ "model_state_dict": denoiser.state_dict(),
401
+ "hidden_dim": int(args.hidden_dim),
402
+ "max_delta": float(args.max_delta),
403
+ "denoiser_backbone": str(args.denoiser_backbone),
404
+ "transformer_layers": int(args.transformer_layers),
405
+ "transformer_heads": int(args.transformer_heads),
406
+ "transformer_dropout": float(args.transformer_dropout),
407
+ "torsion_mode_max": int(args.torsion_mode_max),
408
+ "source_checkpoint": args.checkpoint,
409
+ },
410
+ os.path.join(args.output_dir, "best.pth"),
411
+ )
412
+
413
+
414
+ if __name__ == "__main__":
415
+ main()