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.
- args_parse.py +593 -0
- candidate_corrector.py +161 -0
- candidate_scorer.py +359 -0
- conformend/__init__.py +36 -0
- conformend/refiner.py +25 -0
- dataset/__init__.py +1 -0
- dataset/drugdataset.py +644 -0
- dataset/manifold.py +237 -0
- dataset/sharded_drugdataset.py +124 -0
- dataset/smiles2graph.py +217 -0
- dualmapref/__init__.py +24 -0
- dualmapref/refiner.py +16 -0
- dualmapref-0.2.8.dist-info/LICENSE +21 -0
- dualmapref-0.2.8.dist-info/METADATA +167 -0
- dualmapref-0.2.8.dist-info/RECORD +186 -0
- dualmapref-0.2.8.dist-info/WHEEL +5 -0
- dualmapref-0.2.8.dist-info/entry_points.txt +10 -0
- dualmapref-0.2.8.dist-info/top_level.txt +29 -0
- exputils.py +289 -0
- infer.py +23 -0
- infer_base_conformers.py +5589 -0
- infer_mean_dispersion_torsion.py +1117 -0
- infer_torsion.py +752 -0
- infer_torsional_denoiser.py +1021 -0
- manimol/__init__.py +30 -0
- manimol/__main__.py +6 -0
- manimol/cli.py +36 -0
- manimol/full_cli.py +41 -0
- manimol/legacy_imports.py +43 -0
- manimol/manifest.py +56 -0
- manimol/postprocess.py +148 -0
- manimol/priors.py +60 -0
- manimol/protocols.py +119 -0
- manimol/refiner.py +645 -0
- manimol/runtime.py +194 -0
- manimol/selection.py +85 -0
- manimol/torsion.py +22 -0
- manimol/train_cli.py +14 -0
- mixture_flow/src/__init__.py +1 -0
- mixture_flow/src/_path.py +7 -0
- mixture_flow/src/infer28_mixture_torsion_flow.py +1093 -0
- mixture_flow/src/mixture_torsion_flow.py +291 -0
- mixture_flow/src/summarize_mixture_debug.py +80 -0
- mixture_flow/src/train28_mixture_torsion_flow.py +583 -0
- mixture_torsion_flow.py +7 -0
- models/ manifold_learning.py +86 -0
- models/__init__.py +8 -0
- models/dist.py +273 -0
- models/dist2coords.py +23 -0
- models/egnn.py +107 -0
- models/experimental_backbones.py +364 -0
- models/gnnconv.py +512 -0
- models/kernel_inversion.py +141 -0
- models/kernels.py +427 -0
- models/losses.py +154 -0
- models/mean_dispersion_bridge.py +119 -0
- models/mean_dispersion_torsion_context.py +155 -0
- models/model.py +73 -0
- models/model0.py +2375 -0
- models/vis.py +128 -0
- pgraph_controls.py +107 -0
- scripts/__init__.py +2 -0
- scripts/analyze_basin_alignment.py +63 -0
- scripts/analyze_hif2a_conformer_aggregation.py +267 -0
- scripts/analyze_hif2a_contact_pharmacophore.py +1111 -0
- scripts/analyze_hif2a_fixed_budget.py +202 -0
- scripts/analyze_hif2a_pharmacophore.py +405 -0
- scripts/analyze_hif2a_pharmacophore_match_metric.py +386 -0
- scripts/analyze_p_control_candidate_flow.py +154 -0
- scripts/analyze_scaffold_basin.py +83 -0
- scripts/audit_dispersion_proposals.py +208 -0
- scripts/audit_etflow_protocol.py +258 -0
- scripts/audit_external_overlap.py +150 -0
- scripts/audit_oldbest_fulltrainval_split.py +82 -0
- scripts/audit_pdbbind_contact_pharmacophores.py +146 -0
- scripts/audit_qm9_geomol_test_split.py +94 -0
- scripts/audit_stage1_stage2_cross.py +131 -0
- scripts/build_geom_drugs_lowref_diagnostic.py +84 -0
- scripts/build_qm9_backfill_manifest.py +99 -0
- scripts/check_etflow_runtime.py +56 -0
- scripts/compare_prior_sources.py +122 -0
- scripts/compose_binding_mode_figure.py +87 -0
- scripts/compose_hif2a_contact_pharmacophore_suppfig.py +255 -0
- scripts/compose_hif2a_functional_geometry_pipeline.py +266 -0
- scripts/compose_manimol_internal_architecture.py +291 -0
- scripts/diagnose_flow_basin_intervention.py +54 -0
- scripts/diagnose_hif2a_pharmacophore_budget.py +185 -0
- scripts/diagnose_route2_p_ranking.py +123 -0
- scripts/discover_binding_mode_inputs.py +30 -0
- scripts/evaluate_functional_prior_stage1.py +230 -0
- scripts/evaluate_geomanimol.py +74 -0
- scripts/evaluate_geomanimol_flow.py +23 -0
- scripts/evaluate_geomanimol_multiscaffold.py +46 -0
- scripts/evaluate_geomanimol_residual.py +45 -0
- scripts/evaluate_geomanimol_torsion.py +40 -0
- scripts/evaluate_hif2a_bioactive_enrichment.py +91 -0
- scripts/evaluate_hif2a_pms_suite.py +440 -0
- scripts/evaluate_pdbbind_contact_pms.py +155 -0
- scripts/evaluate_platinum_external.py +114 -0
- scripts/evaluate_platinum_pool.py +82 -0
- scripts/evaluate_route2_calibrated_p.py +104 -0
- scripts/evaluate_route2_library_components.py +596 -0
- scripts/evaluate_route2_p_basin_budget.py +288 -0
- scripts/evaluate_stage1_checkpoint_only.py +30 -0
- scripts/export_dispersion_bond_audit.py +136 -0
- scripts/export_top20_shards.py +207 -0
- scripts/external_validation_metrics.py +152 -0
- scripts/fit_topology_prior.py +117 -0
- scripts/frozen_dispersion_audit.py +281 -0
- scripts/geomanimol_debug.py +50 -0
- scripts/geomanimol_smoke.py +37 -0
- scripts/infer_etflow_matched.py +524 -0
- scripts/inspect_checkpoint.py +12 -0
- scripts/inspect_conformer_capacity.py +71 -0
- scripts/inspect_pool.py +12 -0
- scripts/make_figure3_selection_loss.py +474 -0
- scripts/make_figure3_selection_summary.py +275 -0
- scripts/make_geom_debug_subset.py +62 -0
- scripts/make_low_reference_test_subset.py +70 -0
- scripts/merge_stage1_into_stage2.py +82 -0
- scripts/place_hif2a_candidates_for_evaluation.py +66 -0
- scripts/plot_hif2a_low_budget_efficiency.py +100 -0
- scripts/plot_prior_validation.py +48 -0
- scripts/precompute_stage2_assignments.py +90 -0
- scripts/prepare_bace_activity.py +98 -0
- scripts/prepare_bace_etkdg_benchmark.py +90 -0
- scripts/prepare_figure5_4x4_cases.py +470 -0
- scripts/prepare_geom_drugs_geomol_top20.py +472 -0
- scripts/prepare_pdbbind_core_raw.py +90 -0
- scripts/prepare_platinum_raw.py +74 -0
- scripts/prepare_pubchem_etkdg.py +54 -0
- scripts/rebuild_hif2a_final_sdf_and_metrics.py +55 -0
- scripts/rebuild_hif2a_fixed_pool_sweep.py +175 -0
- scripts/rebuild_hif2a_strict.py +220 -0
- scripts/recompute_hif2a_bootstrap.py +63 -0
- scripts/reference_free_geometry.py +112 -0
- scripts/render_binding_modes.py +413 -0
- scripts/render_figure5_4x4.py +330 -0
- scripts/render_figure6_pharmacophore_pymol.py +162 -0
- scripts/render_hif2a_contact_pharmacophore_pymol.py +414 -0
- scripts/render_hif2a_figure11.py +397 -0
- scripts/run_bace_2d_baseline.py +73 -0
- scripts/run_drugs_validation_matrix.py +225 -0
- scripts/run_external_reference_free.py +53 -0
- scripts/run_manimol_finalk_sensitivity.py +106 -0
- scripts/run_manimol_oversampling_sensitivity.py +109 -0
- scripts/run_pdisp_matched_intervention.py +116 -0
- scripts/run_stage1_stage2_cross20.py +83 -0
- scripts/score_hif2a_candidates_with_pgraph.py +221 -0
- scripts/summarize_dispersion_intervention.py +88 -0
- scripts/test_mean_dispersion_bridge.py +50 -0
- scripts/train_dispersion_head_diagnostic.py +320 -0
- scripts/train_dispersion_head_streaming.py +519 -0
- scripts/train_geomanimol.py +100 -0
- scripts/train_geomanimol_flow.py +26 -0
- scripts/train_geomanimol_residual.py +70 -0
- scripts/train_geomanimol_torsion.py +50 -0
- scripts/train_quantile_representation_diagnostic.py +204 -0
- scripts/validate_mean_dispersion_prior.py +173 -0
- scripts/validate_packed_shard.py +41 -0
- scripts/validate_stage1_prior.py +221 -0
- scripts/validate_top20_shards.py +36 -0
- scripts/validation/__init__.py +1 -0
- scripts/validation/hif2a_downstream_baselines.py +105 -0
- scripts/validation/hif2a_pairwise_ranker.py +218 -0
- scripts/verify_binding_mode_figure.py +47 -0
- torsion_manifold.py +281 -0
- train.py +78 -0
- train_graph_encoder.py +206 -0
- train_local_torsion_corrector.py +511 -0
- train_mean_dispersion_torsion_prior.py +329 -0
- train_probability_basin.py +235 -0
- train_torsion_generator.py +1631 -0
- train_torsion_manifold_prior.py +258 -0
- train_torsional_denoiser.py +415 -0
- trainer.py +1038 -0
- utils/__init__.py +7 -0
- utils/checkpoint.py +40 -0
- utils/device.py +17 -0
- utils/helpers.py +98 -0
- utils/kabsch.py +29 -0
- utils/lookup_table.py +164 -0
- utils/metrics.py +50 -0
- utils/optuna.py +111 -0
- utils/save_mol.py +366 -0
- 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()
|