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,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()
|