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
models/kernels.py
ADDED
|
@@ -0,0 +1,427 @@
|
|
|
1
|
+
# kernels.py
|
|
2
|
+
import numpy as np
|
|
3
|
+
from dataclasses import dataclass
|
|
4
|
+
|
|
5
|
+
EPS = 1e-12
|
|
6
|
+
|
|
7
|
+
# ========== 工具 ==========
|
|
8
|
+
def pairwise_dist(Y: np.ndarray) -> np.ndarray:
|
|
9
|
+
diff = Y[:, None, :] - Y[None, :, :]
|
|
10
|
+
return np.sqrt((diff**2).sum(-1) + EPS)
|
|
11
|
+
|
|
12
|
+
def clamp01(Q: np.ndarray) -> np.ndarray:
|
|
13
|
+
Q = np.clip(Q, 1e-12, 1.0 - 1e-12)
|
|
14
|
+
np.fill_diagonal(Q, 0.0)
|
|
15
|
+
return Q
|
|
16
|
+
|
|
17
|
+
# ========== UMAP 的 a,b 拟合 ==========
|
|
18
|
+
def _umap_target_curve(x, min_dist=0.5, spread=1.0):
|
|
19
|
+
y = np.ones_like(x)
|
|
20
|
+
m = x > min_dist
|
|
21
|
+
y[m] = np.exp(-(x[m] - min_dist) / spread)
|
|
22
|
+
return y
|
|
23
|
+
|
|
24
|
+
def find_ab_params(min_dist=0.5, spread=1.0):
|
|
25
|
+
"""拟合 1/(1+a x^{2b}) 逼近 UMAP 目标曲线(与官方思路一致)"""
|
|
26
|
+
from scipy.optimize import curve_fit
|
|
27
|
+
x = np.linspace(0, 3.0*spread, 300)
|
|
28
|
+
y = _umap_target_curve(x, min_dist=min_dist, spread=spread)
|
|
29
|
+
f = lambda x,a,b: 1.0 / (1.0 + a * (x ** (2.0*b)))
|
|
30
|
+
(a,b), _ = curve_fit(f, x, y, p0=(1.6, 0.8), maxfev=10000)
|
|
31
|
+
return float(a), float(b)
|
|
32
|
+
|
|
33
|
+
# ========== 基类接口 ==========
|
|
34
|
+
class BaseKernel:
|
|
35
|
+
def forward(self, D: np.ndarray) -> np.ndarray:
|
|
36
|
+
raise NotImplementedError
|
|
37
|
+
def dQdd(self, D: np.ndarray) -> np.ndarray:
|
|
38
|
+
raise NotImplementedError
|
|
39
|
+
def inv(self, Q: np.ndarray) -> np.ndarray:
|
|
40
|
+
raise NotImplementedError
|
|
41
|
+
|
|
42
|
+
# ========== 低维 UMAP 核 ==========
|
|
43
|
+
@dataclass
|
|
44
|
+
class UMAPLowKernel(BaseKernel):
|
|
45
|
+
a: float = 1.6
|
|
46
|
+
b: float = 0.8
|
|
47
|
+
def forward(self, D):
|
|
48
|
+
Q = 1.0 / (1.0 + self.a * (np.maximum(D, EPS) ** (2.0*self.b)))
|
|
49
|
+
return clamp01(Q)
|
|
50
|
+
def dQdd(self, D):
|
|
51
|
+
Dp = np.maximum(D, EPS)
|
|
52
|
+
num = (2.0 * self.a * self.b) * (Dp ** (2.0*self.b - 1.0))
|
|
53
|
+
den = (1.0 + self.a * (Dp ** (2.0*self.b))) ** 2
|
|
54
|
+
return - num / (den + EPS)
|
|
55
|
+
def inv(self, Q):
|
|
56
|
+
x = ((1.0/np.clip(Q,1e-12,1-1e-12) - 1.0) / self.a).clip(min=0.0)
|
|
57
|
+
return x ** (1.0/(2.0*self.b))
|
|
58
|
+
|
|
59
|
+
# ========== Gaussian 核 ==========
|
|
60
|
+
@dataclass
|
|
61
|
+
class GaussianKernel(BaseKernel):
|
|
62
|
+
sigma: float = 1.0
|
|
63
|
+
def forward(self, D):
|
|
64
|
+
s2 = self.sigma**2
|
|
65
|
+
Q = np.exp(-(D**2) / (2.0*s2))
|
|
66
|
+
return clamp01(Q)
|
|
67
|
+
def dQdd(self, D):
|
|
68
|
+
s2 = self.sigma**2
|
|
69
|
+
Q = self.forward(D)
|
|
70
|
+
return - (D / s2) * Q
|
|
71
|
+
def inv(self, Q):
|
|
72
|
+
s2 = self.sigma**2
|
|
73
|
+
return np.sqrt(np.maximum(-2.0*s2*np.log(np.clip(Q,1e-12,1-1e-12)), 0.0))
|
|
74
|
+
|
|
75
|
+
# ========== Student-t 核 ==========
|
|
76
|
+
@dataclass
|
|
77
|
+
class StudentTKernel(BaseKernel):
|
|
78
|
+
nu: float = 1.0
|
|
79
|
+
def forward(self, D):
|
|
80
|
+
Q = 1.0 / (1.0 + (D**2)/self.nu)
|
|
81
|
+
return clamp01(Q)
|
|
82
|
+
def dQdd(self, D):
|
|
83
|
+
nu = self.nu
|
|
84
|
+
Dp = np.maximum(D, EPS)
|
|
85
|
+
return - (2.0 * Dp / nu) / ((1.0 + (Dp**2)/nu) ** 2 + EPS)
|
|
86
|
+
def inv(self, Q):
|
|
87
|
+
x = (1.0/np.clip(Q,1e-12,1-1e-12) - 1.0) * self.nu
|
|
88
|
+
return np.sqrt(np.maximum(x, 0.0))
|
|
89
|
+
|
|
90
|
+
# ========== UMAP-P 行自适应核(高维构 P 所用:exp 版本) ==========
|
|
91
|
+
class UMAPRowExpKernel(BaseKernel):
|
|
92
|
+
"""
|
|
93
|
+
低维也使用高维行核 + fuzzy union:
|
|
94
|
+
q_i(d) = exp(- max(0, d - rho_i) / sigma_i )
|
|
95
|
+
Q = q_i + q_j - q_i*q_j
|
|
96
|
+
需要:rho, sigma 为s长度 N 的数组
|
|
97
|
+
"""
|
|
98
|
+
def __init__(self, rho: np.ndarray, sigma: np.ndarray):
|
|
99
|
+
self.rho = np.asarray(rho, dtype=float)
|
|
100
|
+
self.sigma = np.asarray(sigma, dtype=float)
|
|
101
|
+
assert self.rho.ndim == self.sigma.ndim == 1
|
|
102
|
+
assert self.rho.shape == self.sigma.shape
|
|
103
|
+
|
|
104
|
+
def _qi(self, D):
|
|
105
|
+
Ri = self.rho[:, None]
|
|
106
|
+
Si = (self.sigma[:, None] + EPS)
|
|
107
|
+
X = D - Ri
|
|
108
|
+
X[X < 0.0] = 0.0
|
|
109
|
+
return np.exp(- X / Si)
|
|
110
|
+
|
|
111
|
+
def forward(self, D):
|
|
112
|
+
qi = self._qi(D)
|
|
113
|
+
qj = qi.T
|
|
114
|
+
Q = qi + qj - qi*qj
|
|
115
|
+
return clamp01(Q)
|
|
116
|
+
|
|
117
|
+
def dQdd(self, D):
|
|
118
|
+
N = D.shape[0]
|
|
119
|
+
Ri = self.rho[:, None]
|
|
120
|
+
Rj = self.rho[None, :]
|
|
121
|
+
Si = (self.sigma[:, None] + EPS)
|
|
122
|
+
Sj = (self.sigma[None, :] + EPS)
|
|
123
|
+
|
|
124
|
+
qi = self._qi(D)
|
|
125
|
+
qj = qi.T
|
|
126
|
+
|
|
127
|
+
mask_i = (D > Ri).astype(float)
|
|
128
|
+
mask_j = (D > Rj).astype(float)
|
|
129
|
+
dqi_dd = - (qi / Si) * mask_i
|
|
130
|
+
dqj_dd = - (qj / Sj) * mask_j
|
|
131
|
+
|
|
132
|
+
dQdd = dqi_dd*(1.0 - qj) + dqj_dd*(1.0 - qi)
|
|
133
|
+
return dQdd
|
|
134
|
+
|
|
135
|
+
def inv(self, Q):
|
|
136
|
+
raise NotImplementedError("Fuzzy-union 的行核无简单解析逆。")
|
|
137
|
+
|
|
138
|
+
# ========== UMAP-P 同族自适应核(折中版:把 exp 换成 UMAP 族) ==========
|
|
139
|
+
class UMAPRowFamilyKernel(BaseKernel):
|
|
140
|
+
"""
|
|
141
|
+
q_i(d) = 1 / (1 + a * Z^{2b}), Z = max(0, (d - rho_i)/sigma_i)
|
|
142
|
+
Q = q_i + q_j - q_i*q_j
|
|
143
|
+
"""
|
|
144
|
+
def __init__(self, rho: np.ndarray, sigma: np.ndarray, a: float = 1.6, b: float = 0.8):
|
|
145
|
+
self.rho = np.asarray(rho, dtype=float)
|
|
146
|
+
self.sigma = np.asarray(sigma, dtype=float)
|
|
147
|
+
self.a = float(a); self.b = float(b)
|
|
148
|
+
assert self.rho.ndim == self.sigma.ndim == 1
|
|
149
|
+
assert self.rho.shape == self.sigma.shape
|
|
150
|
+
|
|
151
|
+
def _Z(self, D):
|
|
152
|
+
Ri = self.rho[:, None]
|
|
153
|
+
Si = (self.sigma[:, None] + EPS)
|
|
154
|
+
Z = (D - Ri) / Si
|
|
155
|
+
Z[Z < 0.0] = 0.0
|
|
156
|
+
return Z, Si
|
|
157
|
+
|
|
158
|
+
def _qi(self, D):
|
|
159
|
+
Z, _ = self._Z(D)
|
|
160
|
+
qi = 1.0 / (1.0 + self.a * (np.maximum(Z, 0.0) ** (2.0*self.b)))
|
|
161
|
+
return qi
|
|
162
|
+
|
|
163
|
+
def forward(self, D):
|
|
164
|
+
qi = self._qi(D)
|
|
165
|
+
qj = qi.T
|
|
166
|
+
Q = qi + qj - qi*qj
|
|
167
|
+
return clamp01(Q)
|
|
168
|
+
|
|
169
|
+
def dQdd(self, D):
|
|
170
|
+
Z, Si = self._Z(D)
|
|
171
|
+
qi = self._qi(D)
|
|
172
|
+
qj = qi.T
|
|
173
|
+
|
|
174
|
+
Zi = np.maximum(Z, 0.0)
|
|
175
|
+
mask_i = (Zi > 0.0).astype(float)
|
|
176
|
+
|
|
177
|
+
# dqi/dd = -(2ab * Z^{2b-1}) / (1 + a Z^{2b})^2 * (1/Si) * mask
|
|
178
|
+
num = (2.0*self.a*self.b) * (Zi ** (2.0*self.b - 1.0))
|
|
179
|
+
den = (1.0 + self.a * (Zi ** (2.0*self.b))) ** 2
|
|
180
|
+
dqi_dd = - (num / (den + EPS)) * (1.0/Si) * mask_i
|
|
181
|
+
|
|
182
|
+
dqj_dd = dqi_dd.T # 对称(Z 用列参数时与 i/j 互换)
|
|
183
|
+
|
|
184
|
+
dQdd = dqi_dd*(1.0 - qj) + dqj_dd*(1.0 - qi)
|
|
185
|
+
return dQdd
|
|
186
|
+
|
|
187
|
+
def inv(self, Q):
|
|
188
|
+
raise NotImplementedError("Fuzzy-union 的行核无简单解析逆。")
|
|
189
|
+
|
|
190
|
+
|
|
191
|
+
# ===== Smooth-k 自适应行核(UMAP-P 风格,继承 BaseKernel)=====
|
|
192
|
+
from typing import Optional
|
|
193
|
+
import numpy as np
|
|
194
|
+
|
|
195
|
+
# 复用你文件中已有的工具;若命名不同,把这两处改成你的函数名
|
|
196
|
+
# - pairwise_dist(Y) -> (N,N) 距离
|
|
197
|
+
# - clamp01(Q) -> 将 Q 裁剪到 (1e-12, 1-1e-12),并对角置 0
|
|
198
|
+
EPS = 1e-12
|
|
199
|
+
|
|
200
|
+
class SmoothKRowExpKernel(BaseKernel):
|
|
201
|
+
"""
|
|
202
|
+
行自适应核 + smooth-k + fuzzy union:
|
|
203
|
+
q_i(d) = exp( - max(0, d - rho_i) / sigma_i )
|
|
204
|
+
Q = q_i + q_j - q_i*q_j (fuzzy union)
|
|
205
|
+
- 候选边:hop<=K 且非对角且 dist 有限
|
|
206
|
+
- 每行目标“近邻数” smooth-k: sum_j q_i(d_ij) = log2(k_i + 1)
|
|
207
|
+
用二分法解 σ_i
|
|
208
|
+
- 候选≤2 的行做“冻结”(等权),避免数值不稳定
|
|
209
|
+
|
|
210
|
+
使用流程:
|
|
211
|
+
1) ker = SmoothKRowExpKernel(K_HOP_MAX=2).fit_from_dist(dist, hop, mol)
|
|
212
|
+
2) P = ker.build_P_from_dist(dist, hop, mol) # 高维 P(对称)
|
|
213
|
+
3) 低维也想用同族核时:把全局 KERNEL = ker,然后用你的 CE/梯度循环即可
|
|
214
|
+
"""
|
|
215
|
+
|
|
216
|
+
def __init__(self,
|
|
217
|
+
K_HOP_MAX: int = 2,
|
|
218
|
+
k_offset: int = 2,
|
|
219
|
+
k_min: int = 3,
|
|
220
|
+
k_max: int = 8,
|
|
221
|
+
sigma_lo: float = 1e-6,
|
|
222
|
+
sigma_hi: float = 1.0,
|
|
223
|
+
sigma_iters: int = 32):
|
|
224
|
+
# 超参
|
|
225
|
+
self.K_HOP_MAX = K_HOP_MAX
|
|
226
|
+
self.k_offset = k_offset
|
|
227
|
+
self.k_min = k_min
|
|
228
|
+
self.k_max = k_max
|
|
229
|
+
self.sigma_lo = sigma_lo
|
|
230
|
+
self.sigma_hi = sigma_hi
|
|
231
|
+
self.sigma_iters = sigma_iters
|
|
232
|
+
# 拟合后得到的参数
|
|
233
|
+
self.rho: Optional[np.ndarray] = None # (N,)
|
|
234
|
+
self.sigma: Optional[np.ndarray] = None # (N,)
|
|
235
|
+
self.N: Optional[int] = None
|
|
236
|
+
# 辅助掩码与冻结行
|
|
237
|
+
self.cand_mask: Optional[np.ndarray] = None # (N,N) bool
|
|
238
|
+
self.frozen_row: Optional[np.ndarray] = None # (N,) bool
|
|
239
|
+
self.frozen_qrow: Optional[np.ndarray] = None # (N,N) float(仅冻结行有效)
|
|
240
|
+
|
|
241
|
+
# --------- 工具:smooth-k σ 行二分 ----------
|
|
242
|
+
@staticmethod
|
|
243
|
+
def _sigma_binary_search_row(k_of_sigma, fixed_k, lo, hi, iters):
|
|
244
|
+
while k_of_sigma(hi) < fixed_k and hi < 1e6:
|
|
245
|
+
hi *= 2.0
|
|
246
|
+
for _ in range(iters):
|
|
247
|
+
mid = 0.5 * (lo + hi)
|
|
248
|
+
if k_of_sigma(mid) < fixed_k:
|
|
249
|
+
lo = mid
|
|
250
|
+
else:
|
|
251
|
+
hi = mid
|
|
252
|
+
return 0.5 * (lo + hi)
|
|
253
|
+
|
|
254
|
+
@staticmethod
|
|
255
|
+
def _prob_row_from_sigma(sig, d_row, rho_i):
|
|
256
|
+
x = d_row - rho_i
|
|
257
|
+
x[x < 0.0] = 0.0
|
|
258
|
+
return np.exp(- x / (sig + EPS))
|
|
259
|
+
|
|
260
|
+
@staticmethod
|
|
261
|
+
def _k_from_prob(prob_row):
|
|
262
|
+
# smooth-k: sum(p) = log2(k+1) => k = 2^{sum p} - 1
|
|
263
|
+
return np.power(2.0, float(prob_row.sum())) - 1.0
|
|
264
|
+
|
|
265
|
+
@staticmethod
|
|
266
|
+
def _degree_based_k(mol, n, k_offset, k_min, k_max):
|
|
267
|
+
if mol is not None:
|
|
268
|
+
try:
|
|
269
|
+
deg = np.array([a.GetDegree() for a in mol.GetAtoms()], dtype=int)
|
|
270
|
+
return np.clip(deg + k_offset, k_min, k_max).astype(float)
|
|
271
|
+
except Exception:
|
|
272
|
+
pass
|
|
273
|
+
# 回退:常数
|
|
274
|
+
return np.full(n, float((k_min + k_max) // 2), dtype=float)
|
|
275
|
+
|
|
276
|
+
# --------- 拟合每行 (rho_i, sigma_i) ----------
|
|
277
|
+
def fit_from_dist(self, dist: np.ndarray, hop: Optional[np.ndarray],
|
|
278
|
+
mol=None, k_i: Optional[np.ndarray] = None):
|
|
279
|
+
"""
|
|
280
|
+
dist: (N,N) 距离矩阵(可含 inf)
|
|
281
|
+
hop : (N,N) 最短 hop;None 则默认全连通
|
|
282
|
+
mol : RDKit Mol,仅用于用度数确定 k_i;可为 None
|
|
283
|
+
k_i : (N,) 每行目标 k(可自传);默认用 deg+offset 并夹 [k_min,k_max]
|
|
284
|
+
"""
|
|
285
|
+
n = dist.shape[0]
|
|
286
|
+
self.N = n
|
|
287
|
+
|
|
288
|
+
# 候选集合:hop<=K,非自身,dist 有限
|
|
289
|
+
if hop is not None:
|
|
290
|
+
cand = (hop <= self.K_HOP_MAX)
|
|
291
|
+
else:
|
|
292
|
+
cand = np.ones_like(dist, dtype=bool)
|
|
293
|
+
eye = np.eye(n, dtype=bool)
|
|
294
|
+
cand = cand & (~eye) & np.isfinite(dist)
|
|
295
|
+
self.cand_mask = cand
|
|
296
|
+
|
|
297
|
+
# 目标 k_i
|
|
298
|
+
if k_i is None:
|
|
299
|
+
k_i = self._degree_based_k(mol, n, self.k_offset, self.k_min, self.k_max)
|
|
300
|
+
|
|
301
|
+
rho = np.zeros(n, dtype=float)
|
|
302
|
+
sigma = np.zeros(n, dtype=float)
|
|
303
|
+
frozen_row = np.zeros(n, dtype=bool)
|
|
304
|
+
frozen_qrow = np.zeros((n, n), dtype=float)
|
|
305
|
+
|
|
306
|
+
for i in range(n):
|
|
307
|
+
cand_i = np.where(cand[i])[0]
|
|
308
|
+
m = cand_i.size
|
|
309
|
+
if m == 0:
|
|
310
|
+
rho[i] = 0.0; sigma[i] = 0.0; frozen_row[i] = True
|
|
311
|
+
continue
|
|
312
|
+
|
|
313
|
+
d_i = dist[i, cand_i].astype(float)
|
|
314
|
+
pos = d_i[d_i > 0.0]
|
|
315
|
+
rho_i = float(pos.min()) if pos.size > 0 else 0.0
|
|
316
|
+
rho[i] = rho_i
|
|
317
|
+
|
|
318
|
+
if m <= 2:
|
|
319
|
+
frozen_row[i] = True
|
|
320
|
+
frozen_qrow[i, cand_i] = 1.0 / m
|
|
321
|
+
sigma[i] = 0.0
|
|
322
|
+
continue
|
|
323
|
+
|
|
324
|
+
k_target = float(min(k_i[i], m))
|
|
325
|
+
|
|
326
|
+
def k_of_sigma(sig):
|
|
327
|
+
p = self._prob_row_from_sigma(sig, d_i, rho_i)
|
|
328
|
+
return self._k_from_prob(p)
|
|
329
|
+
|
|
330
|
+
sigma_i = self._sigma_binary_search_row(
|
|
331
|
+
k_of_sigma, k_target, lo=self.sigma_lo, hi=self.sigma_hi, iters=self.sigma_iters
|
|
332
|
+
)
|
|
333
|
+
sigma[i] = sigma_i
|
|
334
|
+
|
|
335
|
+
self.rho = rho
|
|
336
|
+
self.sigma = sigma
|
|
337
|
+
self.frozen_row = frozen_row
|
|
338
|
+
self.frozen_qrow = frozen_qrow
|
|
339
|
+
return self
|
|
340
|
+
|
|
341
|
+
# --------- 行核 qi 与前向 Q(D) ----------
|
|
342
|
+
def _ensure_fit(self):
|
|
343
|
+
if self.rho is None or self.sigma is None:
|
|
344
|
+
raise RuntimeError("SmoothKRowExpKernel: call fit_from_dist(...) first.")
|
|
345
|
+
|
|
346
|
+
def _qi_matrix(self, D: np.ndarray) -> np.ndarray:
|
|
347
|
+
self._ensure_fit()
|
|
348
|
+
n = D.shape[0]
|
|
349
|
+
Ri = self.rho[:, None]
|
|
350
|
+
Si = (self.sigma[:, None] + EPS)
|
|
351
|
+
X = D - Ri
|
|
352
|
+
X[X < 0.0] = 0.0
|
|
353
|
+
qi = np.exp(- X / Si)
|
|
354
|
+
|
|
355
|
+
# 非候选置 0
|
|
356
|
+
if self.cand_mask is not None:
|
|
357
|
+
qi = qi * self.cand_mask.astype(float)
|
|
358
|
+
# 冻结行覆盖
|
|
359
|
+
if self.frozen_row is not None and self.frozen_row.any():
|
|
360
|
+
fr = self.frozen_row
|
|
361
|
+
qi[fr] = self.frozen_qrow[fr]
|
|
362
|
+
return qi
|
|
363
|
+
|
|
364
|
+
def forward(self, D: np.ndarray) -> np.ndarray:
|
|
365
|
+
"""Q = q_i + q_j - q_i*q_j;随后 clamp 到 (1e-12, 1-1e-12),对角置 0。"""
|
|
366
|
+
qi = self._qi_matrix(D)
|
|
367
|
+
qj = qi.T
|
|
368
|
+
Q = qi + qj - qi * qj
|
|
369
|
+
# 用你文件里的 clamp01;若名为 _clamp01 就相应替换
|
|
370
|
+
return clamp01(Q)
|
|
371
|
+
|
|
372
|
+
# --------- dQ/dd(用于 CE 梯度) ----------
|
|
373
|
+
def dQdd(self, D: np.ndarray) -> np.ndarray:
|
|
374
|
+
"""
|
|
375
|
+
dQ/dd = (dq_i/dd)*(1 - q_j) + (dq_j/dd)*(1 - q_i)
|
|
376
|
+
其中 dq_i/dd = 0 (d <= rho_i);否则 = - q_i / sigma_i
|
|
377
|
+
冻结行对 dQ/dd 的贡献为 0;非候选边导数置 0。
|
|
378
|
+
"""
|
|
379
|
+
self._ensure_fit()
|
|
380
|
+
n = D.shape[0]
|
|
381
|
+
Ri = self.rho[:, None]
|
|
382
|
+
Rj = self.rho[None, :]
|
|
383
|
+
Si = (self.sigma[:, None] + EPS)
|
|
384
|
+
Sj = (self.sigma[None, :] + EPS)
|
|
385
|
+
|
|
386
|
+
qi = self._qi_matrix(D)
|
|
387
|
+
qj = qi.T
|
|
388
|
+
|
|
389
|
+
mask_i = (D > Ri).astype(float)
|
|
390
|
+
mask_j = (D > Rj).astype(float)
|
|
391
|
+
# 冻结行:梯度置 0
|
|
392
|
+
if self.frozen_row is not None and self.frozen_row.any():
|
|
393
|
+
fr = self.frozen_row
|
|
394
|
+
mask_i[fr] = 0.0 # 行 i 冻结
|
|
395
|
+
mask_j[:, fr] = 0.0 # 列 j 冻结(对称)
|
|
396
|
+
|
|
397
|
+
dqi_dd = - (qi / Si) * mask_i
|
|
398
|
+
dqj_dd = - (qj / Sj) * mask_j
|
|
399
|
+
|
|
400
|
+
dQdd = dqi_dd * (1.0 - qj) + dqj_dd * (1.0 - qi)
|
|
401
|
+
|
|
402
|
+
# 非候选边导数清零
|
|
403
|
+
if self.cand_mask is not None:
|
|
404
|
+
cm = self.cand_mask.astype(float)
|
|
405
|
+
dQdd = dQdd * cm
|
|
406
|
+
np.fill_diagonal(dQdd, 0.0)
|
|
407
|
+
dQdd[~np.isfinite(dQdd)] = 0.0
|
|
408
|
+
return dQdd
|
|
409
|
+
|
|
410
|
+
# --------- inv:行核 + fuzzy-union 无解析逆 ----------
|
|
411
|
+
def inv(self, Q: np.ndarray) -> np.ndarray:
|
|
412
|
+
raise NotImplementedError("SmoothKRowExpKernel: fuzzy-union 行核无简单解析逆。")
|
|
413
|
+
|
|
414
|
+
# --------- 一键构建高维 P ----------
|
|
415
|
+
def build_P_from_dist(self, dist: np.ndarray, hop: Optional[np.ndarray],
|
|
416
|
+
mol=None, k_i: Optional[np.ndarray] = None) -> np.ndarray:
|
|
417
|
+
"""
|
|
418
|
+
用 dist/hop 拟合 (rho, sigma) 后,直接返回对称 P(fuzzy union)。
|
|
419
|
+
"""
|
|
420
|
+
self.fit_from_dist(dist, hop, mol=mol, k_i=k_i)
|
|
421
|
+
qi = self._qi_matrix(dist)
|
|
422
|
+
P = qi + qi.T - qi * qi.T
|
|
423
|
+
return clamp01(P)
|
|
424
|
+
|
|
425
|
+
# ========== —— 适配你的现有函数名 —— ==========
|
|
426
|
+
# 训练前设置全局 KERNEL = 某个实例(例如 UMAPLowKernel(...))
|
|
427
|
+
KERNEL: BaseKernel = UMAPLowKernel(a=1.6, b=0.8)
|
models/losses.py
ADDED
|
@@ -0,0 +1,154 @@
|
|
|
1
|
+
import numpy as np
|
|
2
|
+
import torch
|
|
3
|
+
from .kernels import pairwise_dist, KERNEL # 保留原来的 import,兼容回退
|
|
4
|
+
|
|
5
|
+
_EPS = 1e-12
|
|
6
|
+
|
|
7
|
+
def _to_torch(x, dtype=torch.float32, device=None):
|
|
8
|
+
if torch.is_tensor(x):
|
|
9
|
+
return x.to(dtype=dtype, device=device)
|
|
10
|
+
if isinstance(x, np.ndarray):
|
|
11
|
+
return torch.from_numpy(x).to(dtype=dtype, device=device)
|
|
12
|
+
if isinstance(x, (list, tuple)):
|
|
13
|
+
# 如果 list 里都是 ndarray,就先堆成一个大 ndarray
|
|
14
|
+
try:
|
|
15
|
+
x = np.array(x)
|
|
16
|
+
except Exception:
|
|
17
|
+
# 如果里面是 ragged list,不规则,就保持原状
|
|
18
|
+
pass
|
|
19
|
+
return torch.as_tensor(x, dtype=dtype, device=device)
|
|
20
|
+
|
|
21
|
+
def _xlogy(x, y, eps=_EPS):
|
|
22
|
+
"""数值稳定版 x*log(y),当 x==0 时返回 0。支持 torch tensor。"""
|
|
23
|
+
y = torch.clamp(y, eps, 1.0 - eps)
|
|
24
|
+
mask = (x != 0)
|
|
25
|
+
return torch.where(mask, x * torch.log(y), torch.zeros_like(y))
|
|
26
|
+
|
|
27
|
+
def _xlog1my(x, y, eps=_EPS):
|
|
28
|
+
"""数值稳定版 (1-x)*log(1-y),当 x==1 时返回 0。支持 torch tensor。"""
|
|
29
|
+
y = torch.clamp(y, eps, 1.0 - eps)
|
|
30
|
+
mask = (x != 1)
|
|
31
|
+
return torch.where(mask, (1.0 - x) * torch.log(1.0 - y), torch.zeros_like(y))
|
|
32
|
+
|
|
33
|
+
def _pairwise_dist_torch(Y):
|
|
34
|
+
"""纯 torch 版 pairwise distance (兼容 autograd)。"""
|
|
35
|
+
diff = Y.unsqueeze(1) - Y.unsqueeze(0) # (N, N, dim)
|
|
36
|
+
D = torch.norm(diff, dim=-1) # (N, N)
|
|
37
|
+
return D
|
|
38
|
+
|
|
39
|
+
def _call_pairwise_dist(Y):
|
|
40
|
+
"""尝试用外部 pairwise_dist;失败时使用 torch 本地实现;若外部返回 numpy,转回 tensor。"""
|
|
41
|
+
# 优先尝试外部 pairwise_dist(可能是 numpy 版本)
|
|
42
|
+
try:
|
|
43
|
+
out = pairwise_dist(Y)
|
|
44
|
+
except Exception:
|
|
45
|
+
# 回退到 torch 实现
|
|
46
|
+
return _pairwise_dist_torch(Y)
|
|
47
|
+
else:
|
|
48
|
+
if isinstance(out, np.ndarray):
|
|
49
|
+
return torch.from_numpy(out).to(dtype=Y.dtype, device=Y.device)
|
|
50
|
+
if torch.is_tensor(out):
|
|
51
|
+
return out.to(dtype=Y.dtype, device=Y.device)
|
|
52
|
+
# 其他可转为 tensor 的情况
|
|
53
|
+
return _to_torch(out, dtype=Y.dtype, device=Y.device)
|
|
54
|
+
|
|
55
|
+
def _kernel_forward_tensor(D):
|
|
56
|
+
"""调用 KERNEL.forward(D)。自动在 numpy/tensor 之间转换以兼容旧实现。"""
|
|
57
|
+
try:
|
|
58
|
+
Q = KERNEL.forward(D)
|
|
59
|
+
except Exception:
|
|
60
|
+
# 可能 KERNEL 需要 numpy
|
|
61
|
+
D_np = D.detach().cpu().numpy()
|
|
62
|
+
Q_np = KERNEL.forward(D_np)
|
|
63
|
+
Q = torch.from_numpy(np.asarray(Q_np)).to(dtype=D.dtype, device=D.device)
|
|
64
|
+
else:
|
|
65
|
+
if isinstance(Q, np.ndarray):
|
|
66
|
+
Q = torch.from_numpy(Q).to(dtype=D.dtype, device=D.device)
|
|
67
|
+
elif torch.is_tensor(Q):
|
|
68
|
+
Q = Q.to(dtype=D.dtype, device=D.device)
|
|
69
|
+
return Q
|
|
70
|
+
|
|
71
|
+
def _kernel_dQdd_tensor(D):
|
|
72
|
+
"""调用 KERNEL.dQdd(D),并把输出转成 tensor(兼容 numpy 实现)。"""
|
|
73
|
+
try:
|
|
74
|
+
d = KERNEL.dQdd(D)
|
|
75
|
+
except Exception:
|
|
76
|
+
D_np = D.detach().cpu().numpy()
|
|
77
|
+
d_np = KERNEL.dQdd(D_np)
|
|
78
|
+
d = torch.from_numpy(np.asarray(d_np)).to(dtype=D.dtype, device=D.device)
|
|
79
|
+
else:
|
|
80
|
+
if isinstance(d, np.ndarray):
|
|
81
|
+
d = torch.from_numpy(d).to(dtype=D.dtype, device=D.device)
|
|
82
|
+
elif torch.is_tensor(d):
|
|
83
|
+
d = d.to(dtype=D.dtype, device=D.device)
|
|
84
|
+
return d
|
|
85
|
+
#修改了将P改为一个list
|
|
86
|
+
def CE(P_list, Y):
|
|
87
|
+
"""
|
|
88
|
+
适配 P 为 list 的版本(每个元素对应一个样本的方阵)
|
|
89
|
+
返回每个样本的 CE 矩阵列表(torch tensor 形式)
|
|
90
|
+
CE_ij = - [ P_ij log Q_ij + (1-P_ij) log(1-Q_ij) ],忽略对角项
|
|
91
|
+
"""
|
|
92
|
+
device = None
|
|
93
|
+
if torch.is_tensor(Y):
|
|
94
|
+
device = Y.device
|
|
95
|
+
Y = _to_torch(Y, device=device)
|
|
96
|
+
|
|
97
|
+
CE_matrices = []
|
|
98
|
+
idx = 0 # 用于切分 Y 中的节点
|
|
99
|
+
for Pi in P_list:
|
|
100
|
+
Pi = _to_torch(Pi, dtype=Y.dtype, device=Y.device)
|
|
101
|
+
n = Pi.shape[0]
|
|
102
|
+
|
|
103
|
+
Yi = Y[idx: idx + n] # 每个样本的节点向量
|
|
104
|
+
idx += n
|
|
105
|
+
|
|
106
|
+
D = _call_pairwise_dist(Yi) # (n, n)
|
|
107
|
+
Q = _kernel_forward_tensor(D) # (n, n)
|
|
108
|
+
|
|
109
|
+
eye = torch.eye(n, dtype=torch.bool, device=Y.device)
|
|
110
|
+
CE_mat = - _xlogy(Pi, Q) - _xlog1my(Pi, Q)
|
|
111
|
+
CE_mat = CE_mat.masked_fill(eye, 0.0)
|
|
112
|
+
CE_mat[~torch.isfinite(CE_mat)] = 0.0
|
|
113
|
+
|
|
114
|
+
CE_matrices.append(CE_mat)
|
|
115
|
+
|
|
116
|
+
return CE_matrices
|
|
117
|
+
|
|
118
|
+
def CE_gradient(P, Y):
|
|
119
|
+
"""
|
|
120
|
+
使用 torch 计算 dL/dY 的全量梯度(返回 shape (N, dim))。
|
|
121
|
+
输入 P, Y 可以是 numpy 或 torch(内部会转换)。
|
|
122
|
+
"""
|
|
123
|
+
device = None
|
|
124
|
+
if torch.is_tensor(Y):
|
|
125
|
+
device = Y.device
|
|
126
|
+
Y = _to_torch(Y, device=device)
|
|
127
|
+
P = _to_torch(P, dtype=Y.dtype, device=Y.device)
|
|
128
|
+
|
|
129
|
+
diff = Y.unsqueeze(1) - Y.unsqueeze(0) # (N, N, dim)
|
|
130
|
+
D = _call_pairwise_dist(Y) # (N, N)
|
|
131
|
+
Q = _kernel_forward_tensor(D) # (N, N)
|
|
132
|
+
N = Y.shape[0]
|
|
133
|
+
eye = torch.eye(N, dtype=torch.bool, device=Y.device)
|
|
134
|
+
|
|
135
|
+
# dL/dQ
|
|
136
|
+
Qc = torch.clamp(Q, _EPS, 1.0 - _EPS)
|
|
137
|
+
dLdQ = - (P / Qc) + ((1.0 - P) / (1.0 - Qc))
|
|
138
|
+
dLdQ = dLdQ.masked_fill(eye, 0.0)
|
|
139
|
+
|
|
140
|
+
# dQ/dd
|
|
141
|
+
dQdd = _kernel_dQdd_tensor(D)
|
|
142
|
+
dQdd = dQdd.masked_fill(eye, 0.0)
|
|
143
|
+
|
|
144
|
+
dLdd = dLdQ * dQdd
|
|
145
|
+
dLdd[~torch.isfinite(dLdd)] = 0.0
|
|
146
|
+
|
|
147
|
+
# ∂d/∂y_i : vec = (y_i - y_j) / d_ij
|
|
148
|
+
denom = D.unsqueeze(-1) # (N,N,1)
|
|
149
|
+
vec = diff / denom
|
|
150
|
+
vec[~torch.isfinite(vec)] = 0.0
|
|
151
|
+
|
|
152
|
+
grad = torch.sum(dLdd.unsqueeze(-1) * vec, dim=1) # (N, dim)
|
|
153
|
+
grad[~torch.isfinite(grad)] = 0.0
|
|
154
|
+
return grad
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
"""Mean--dispersion prior utilities for the isolated u/v proposal experiment.
|
|
2
|
+
|
|
3
|
+
The legacy inference path is intentionally untouched. This module contains
|
|
4
|
+
only deterministic tensor transformations that can be unit-tested before the
|
|
5
|
+
new prior is connected to Stage-II sampling.
|
|
6
|
+
"""
|
|
7
|
+
from __future__ import annotations
|
|
8
|
+
|
|
9
|
+
from typing import Optional, Tuple
|
|
10
|
+
|
|
11
|
+
import torch
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
def _torsion_rows(torsion_index: torch.Tensor) -> torch.Tensor:
|
|
15
|
+
"""Return torsions as an ``(n_torsions, 4)`` integer tensor."""
|
|
16
|
+
rows = torch.as_tensor(torsion_index)
|
|
17
|
+
if rows.numel() == 0:
|
|
18
|
+
return torch.empty((0, 4), dtype=torch.long, device=rows.device)
|
|
19
|
+
if rows.dim() != 2:
|
|
20
|
+
raise ValueError("torsion_index must be a rank-2 tensor")
|
|
21
|
+
if rows.size(0) == 4:
|
|
22
|
+
rows = rows.t()
|
|
23
|
+
if rows.size(1) != 4:
|
|
24
|
+
raise ValueError("torsion_index must have four atom indices per torsion")
|
|
25
|
+
return rows.long()
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def _validate_prior(p: torch.Tensor, name: str, upper: float) -> torch.Tensor:
|
|
29
|
+
p = torch.as_tensor(p)
|
|
30
|
+
if p.dim() != 2 or p.size(0) != p.size(1):
|
|
31
|
+
raise ValueError(f"{name} must be a square matrix")
|
|
32
|
+
if not torch.isfinite(p).all():
|
|
33
|
+
raise ValueError(f"{name} contains non-finite values")
|
|
34
|
+
p = 0.5 * (p + p.t())
|
|
35
|
+
p = p.clamp(0.0, upper)
|
|
36
|
+
eye = torch.eye(p.size(0), dtype=torch.bool, device=p.device)
|
|
37
|
+
return p.masked_fill(eye, 0.0)
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def torsion_context_statistics(
|
|
41
|
+
mean_prior: torch.Tensor,
|
|
42
|
+
dispersion_prior: torch.Tensor,
|
|
43
|
+
torsion_index: torch.Tensor,
|
|
44
|
+
*,
|
|
45
|
+
fragment_labels: Optional[torch.Tensor] = None,
|
|
46
|
+
) -> Tuple[torch.Tensor, torch.Tensor]:
|
|
47
|
+
"""Aggregate pairwise priors into one mean/dispersion value per torsion.
|
|
48
|
+
|
|
49
|
+
For a rotatable bond ``b--c``, the preferred context is the mean over
|
|
50
|
+
cross-fragment atom pairs. ``fragment_labels`` should assign each atom to
|
|
51
|
+
one side of that bond. When labels are unavailable, the central pair and
|
|
52
|
+
its four endpoint cross-pairs are used as a conservative local fallback.
|
|
53
|
+
"""
|
|
54
|
+
mean_prior = _validate_prior(mean_prior, "mean_prior", 1.0)
|
|
55
|
+
dispersion_prior = _validate_prior(dispersion_prior, "dispersion_prior", 0.25)
|
|
56
|
+
if mean_prior.shape != dispersion_prior.shape:
|
|
57
|
+
raise ValueError("mean_prior and dispersion_prior must have the same shape")
|
|
58
|
+
rows = _torsion_rows(torsion_index)
|
|
59
|
+
n_atoms = mean_prior.size(0)
|
|
60
|
+
if rows.numel() and int(rows.max()) >= n_atoms:
|
|
61
|
+
raise ValueError("torsion_index contains an atom outside the prior matrix")
|
|
62
|
+
|
|
63
|
+
means, variances = [], []
|
|
64
|
+
for a, b, c, d in rows.tolist():
|
|
65
|
+
if fragment_labels is not None:
|
|
66
|
+
labels = torch.as_tensor(fragment_labels, device=mean_prior.device).reshape(-1)
|
|
67
|
+
if labels.numel() != n_atoms:
|
|
68
|
+
raise ValueError("fragment_labels must have one entry per atom")
|
|
69
|
+
left = torch.nonzero(labels == labels[a], as_tuple=False).flatten()
|
|
70
|
+
right = torch.nonzero(labels == labels[d], as_tuple=False).flatten()
|
|
71
|
+
# If both endpoints accidentally land in the same component, fall
|
|
72
|
+
# back to the central bond neighborhood below.
|
|
73
|
+
if labels[a] != labels[d] and left.numel() and right.numel():
|
|
74
|
+
values_mu = mean_prior[left[:, None], right[None, :]].reshape(-1)
|
|
75
|
+
values_v = dispersion_prior[left[:, None], right[None, :]].reshape(-1)
|
|
76
|
+
else:
|
|
77
|
+
values_mu = None
|
|
78
|
+
values_v = None
|
|
79
|
+
else:
|
|
80
|
+
values_mu = None
|
|
81
|
+
values_v = None
|
|
82
|
+
|
|
83
|
+
if values_mu is None:
|
|
84
|
+
pairs = [(a, c), (a, d), (b, c), (b, d)]
|
|
85
|
+
idx_i = torch.tensor([x for x, _ in pairs], device=mean_prior.device)
|
|
86
|
+
idx_j = torch.tensor([y for _, y in pairs], device=mean_prior.device)
|
|
87
|
+
values_mu = mean_prior[idx_i, idx_j]
|
|
88
|
+
values_v = dispersion_prior[idx_i, idx_j]
|
|
89
|
+
|
|
90
|
+
means.append(values_mu.mean())
|
|
91
|
+
variances.append(values_v.mean())
|
|
92
|
+
|
|
93
|
+
if not means:
|
|
94
|
+
empty = mean_prior.new_empty((0,))
|
|
95
|
+
return empty, empty
|
|
96
|
+
return torch.stack(means), torch.stack(variances)
|
|
97
|
+
|
|
98
|
+
|
|
99
|
+
def dispersion_to_width(
|
|
100
|
+
dispersion: torch.Tensor,
|
|
101
|
+
*,
|
|
102
|
+
width_min: float = 0.10,
|
|
103
|
+
width_max: float = 0.75,
|
|
104
|
+
low: Optional[float] = None,
|
|
105
|
+
high: Optional[float] = None,
|
|
106
|
+
) -> torch.Tensor:
|
|
107
|
+
"""Map nonnegative torsion dispersion to a bounded proposal width."""
|
|
108
|
+
if width_min < 0 or width_max < width_min:
|
|
109
|
+
raise ValueError("width bounds must satisfy 0 <= width_min <= width_max")
|
|
110
|
+
d = torch.as_tensor(dispersion)
|
|
111
|
+
if not torch.isfinite(d).all() or (d < 0).any():
|
|
112
|
+
raise ValueError("dispersion must be finite and nonnegative")
|
|
113
|
+
if d.numel() == 0:
|
|
114
|
+
return d.clone()
|
|
115
|
+
lo = d.min() if low is None else torch.as_tensor(low, dtype=d.dtype, device=d.device)
|
|
116
|
+
hi = d.max() if high is None else torch.as_tensor(high, dtype=d.dtype, device=d.device)
|
|
117
|
+
scale = (hi - lo).clamp_min(torch.finfo(d.dtype).eps)
|
|
118
|
+
normalized = ((d - lo) / scale).clamp(0.0, 1.0)
|
|
119
|
+
return float(width_min) + (float(width_max) - float(width_min)) * normalized
|