#!/usr/bin/env python3 import argparse import json import traceback from pathlib import Path import mdtraj as md import numpy as np import pandas as pd from tqdm import tqdm from sklearn.decomposition import PCA def find_entries(atlas_root, entry="all", max_entries=None): atlas_root = Path(atlas_root) if entry != "all": return [entry] entries = [] for d in sorted(atlas_root.iterdir()): if not d.is_dir(): continue name = d.name pdb = d / f"{name}.pdb" xtcs = sorted(d.glob(f"{name}_R*.xtc")) if pdb.exists() and len(xtcs) > 0: entries.append(name) if max_entries is not None: entries = entries[:max_entries] return entries def load_entry(entry_dir, entry): entry_dir = Path(entry_dir) pdb = entry_dir / f"{entry}.pdb" xtcs = sorted(entry_dir.glob(f"{entry}_R*.xtc")) if not pdb.exists(): raise FileNotFoundError(f"Missing PDB: {pdb}") if len(xtcs) == 0: raise FileNotFoundError(f"Missing XTC files: {entry_dir}") coords_list = [] rep_ids_list = [] frame_ids_list = [] traj_lengths = [] rep_names = [] n_ca_ref = None for rep_id, xtc in enumerate(xtcs): traj = md.load(str(xtc), top=str(pdb)) ca_idx = traj.topology.select("name CA") if len(ca_idx) == 0: raise RuntimeError(f"No CA atoms found: {entry}") if n_ca_ref is None: n_ca_ref = len(ca_idx) elif len(ca_idx) != n_ca_ref: raise RuntimeError(f"CA number mismatch: {entry}") traj_ca = traj.atom_slice(ca_idx) # mdtraj: nm -> Å xyz_A = traj_ca.xyz.astype(np.float32) * 10.0 n_frames = xyz_A.shape[0] coords_list.append(xyz_A) rep_ids_list.append(np.full(n_frames, rep_id, dtype=np.int32)) frame_ids_list.append(np.arange(n_frames, dtype=np.int32)) traj_lengths.append(n_frames) rep_names.append(xtc.stem.replace(f"{entry}_", "")) coords_A = np.concatenate(coords_list, axis=0) rep_ids = np.concatenate(rep_ids_list, axis=0) frame_ids = np.concatenate(frame_ids_list, axis=0) return coords_A, rep_ids, frame_ids, traj_lengths, rep_names, [x.name for x in xtcs] def select_ca_distance_pairs(ref_ca_A, cutoff_A=12.0, min_seq_sep=3, max_pairs=20000): n_ca = ref_ca_A.shape[0] ii, jj = np.triu_indices(n_ca, k=min_seq_sep) diff = ref_ca_A[ii] - ref_ca_A[jj] dist = np.sqrt(np.sum(diff * diff, axis=1)) mask = dist <= cutoff_A pairs = np.stack([ii[mask], jj[mask]], axis=1) pair_dist = dist[mask] if len(pairs) == 0: pairs = np.stack([ii, jj], axis=1) pair_dist = dist if len(pairs) > max_pairs: order = np.argsort(pair_dist) keep = order[:max_pairs] pairs = pairs[keep] return pairs.astype(np.int32) def compute_distance_features(coords_A, ca_pairs, chunk_size=256): n_frames = coords_A.shape[0] feats = [] for s in range(0, n_frames, chunk_size): e = min(s + chunk_size, n_frames) c = coords_A[s:e] diff = c[:, ca_pairs[:, 0], :] - c[:, ca_pairs[:, 1], :] dist = np.sqrt(np.sum(diff * diff, axis=-1)) feats.append(dist.astype(np.float32)) return np.concatenate(feats, axis=0) def fit_tica(Y, traj_lengths, lag=10, tica_dim=3, eps=1e-6): d = Y.shape[1] C0 = np.zeros((d, d), dtype=np.float64) Ct = np.zeros((d, d), dtype=np.float64) count = 0 start = 0 for L in traj_lengths: Yi = Y[start:start + L].astype(np.float64) start += L if L <= lag: continue Y0 = Yi[:-lag] Yt = Yi[lag:] C0 += Y0.T @ Y0 C0 += Yt.T @ Yt Ct += Y0.T @ Yt Ct += Yt.T @ Y0 count += 2 * Y0.shape[0] if count == 0: raise RuntimeError("No valid trajectory length for TICA. Try smaller lag.") C0 /= count Ct /= count C0 = 0.5 * (C0 + C0.T) Ct = 0.5 * (Ct + Ct.T) C0 += eps * np.eye(d) evals0, evecs0 = np.linalg.eigh(C0) keep = evals0 > eps if keep.sum() == 0: raise RuntimeError("Degenerate C0 in TICA.") U0 = evecs0[:, keep] S0 = evals0[keep] W = U0 @ np.diag(1.0 / np.sqrt(S0)) M = W.T @ Ct @ W M = 0.5 * (M + M.T) evals, evecs = np.linalg.eigh(M) order = np.argsort(evals)[::-1] dim = min(tica_dim, len(order)) V = W @ evecs[:, order[:dim]] q = Y @ V q = q.astype(np.float32) q_mean = q.mean(axis=0, keepdims=True) q_std = q.std(axis=0, keepdims=True) + 1e-6 q = (q - q_mean) / q_std return q.astype(np.float32), evals[order[:dim]].astype(np.float32) def build_affinity_topk(q, sigma_k=30, top_k=64): q = q.astype(np.float32) n = q.shape[0] q2 = np.sum(q * q, axis=1, keepdims=True) D2 = q2 + q2.T - 2.0 * (q @ q.T) D2 = np.maximum(D2, 0.0).astype(np.float32) np.fill_diagonal(D2, np.inf) D = np.sqrt(D2) kth = min(max(1, sigma_k), n - 1) sigma = np.partition(D, kth - 1, axis=1)[:, kth - 1] sigma = np.maximum(sigma, 1e-6).astype(np.float32) denom = sigma[:, None] * sigma[None, :] + 1e-6 A = np.exp(-D2 / denom).astype(np.float32) np.fill_diagonal(A, 0.0) top_k = min(top_k, n - 1) top_idx = np.argpartition(-A, top_k, axis=1)[:, :top_k] top_w = np.take_along_axis(A, top_idx, axis=1) order = np.argsort(-top_w, axis=1) top_idx = np.take_along_axis(top_idx, order, axis=1) top_w = np.take_along_axis(top_w, order, axis=1) return A, top_idx.astype(np.int32), top_w.astype(np.float32) def batch_kabsch_rmsd(coords_A, ii, jj, chunk_size=512): rmsds = [] for s in range(0, len(ii), chunk_size): e = min(s + chunk_size, len(ii)) P = coords_A[ii[s:e]].astype(np.float64) Q = coords_A[jj[s:e]].astype(np.float64) P = P - P.mean(axis=1, keepdims=True) Q = Q - Q.mean(axis=1, keepdims=True) C = np.einsum("bni,bnj->bij", P, Q) U, S, Vt = np.linalg.svd(C) det = np.linalg.det(U @ Vt) D = np.zeros_like(C) D[:, 0, 0] = 1.0 D[:, 1, 1] = 1.0 D[:, 2, 2] = np.sign(det) R = U @ D @ Vt P_rot = np.einsum("bni,bij->bnj", P, R) diff = P_rot - Q rmsd = np.sqrt(np.mean(np.sum(diff * diff, axis=-1), axis=1)) rmsds.append(rmsd.astype(np.float32)) return np.concatenate(rmsds, axis=0) def batch_contact_diff(X_dist, ii, jj, chunk_size=256): vals = [] for s in range(0, len(ii), chunk_size): e = min(s + chunk_size, len(ii)) diff = np.abs(X_dist[ii[s:e]] - X_dist[jj[s:e]]) vals.append(diff.mean(axis=1).astype(np.float32)) return np.concatenate(vals, axis=0) def choose_pairs(iu, ju, scores, kind, n_sample): n = len(scores) if n == 0: return np.array([], dtype=np.int64), np.array([], dtype=np.int64) k = min(n_sample, n) if kind == "high": idx = np.argpartition(-scores, k - 1)[:k] idx = idx[np.argsort(-scores[idx])] elif kind == "low": idx = np.argpartition(scores, k - 1)[:k] idx = idx[np.argsort(scores[idx])] elif kind == "mid": med = np.median(scores) d = np.abs(scores - med) idx = np.argpartition(d, k - 1)[:k] idx = idx[np.argsort(d[idx])] else: raise ValueError(kind) return iu[idx], ju[idx] def evaluate_entry(entry, A, coords_A, X_dist, rep_ids, frame_ids, n_sample=3000): n = A.shape[0] iu, ju = np.triu_indices(n, k=1) rows = [] for mode in ["all", "cross", "same"]: if mode == "all": mask = np.ones(len(iu), dtype=bool) elif mode == "cross": mask = rep_ids[iu] != rep_ids[ju] elif mode == "same": mask = rep_ids[iu] == rep_ids[ju] else: raise ValueError(mode) mi = iu[mask] mj = ju[mask] scores = A[mi, mj] for kind in ["high", "mid", "low"]: ii, jj = choose_pairs(mi, mj, scores, kind, n_sample) if len(ii) == 0: rows.append({ "entry": entry, "group": f"{mode}_{kind}", "n_pairs": 0, "rmsd_A_mean": np.nan, "rmsd_A_std": np.nan, "contact_diff_A_mean": np.nan, "contact_diff_A_std": np.nan, "same_rep_frac": np.nan, "time_gap_mean_same_rep": np.nan, "near_time_frac_gap_le_5": np.nan, "near_time_frac_gap_le_20": np.nan, }) continue rmsd = batch_kabsch_rmsd(coords_A, ii, jj) contact_diff = batch_contact_diff(X_dist, ii, jj) same_rep = rep_ids[ii] == rep_ids[jj] same_rep_frac = float(np.mean(same_rep)) if same_rep.any(): gaps = np.abs(frame_ids[ii[same_rep]] - frame_ids[jj[same_rep]]) time_gap_mean = float(np.mean(gaps)) near_5 = float(np.mean(gaps <= 5)) near_20 = float(np.mean(gaps <= 20)) else: time_gap_mean = np.nan near_5 = np.nan near_20 = np.nan rows.append({ "entry": entry, "group": f"{mode}_{kind}", "n_pairs": int(len(ii)), "rmsd_A_mean": float(np.mean(rmsd)), "rmsd_A_std": float(np.std(rmsd)), "contact_diff_A_mean": float(np.mean(contact_diff)), "contact_diff_A_std": float(np.std(contact_diff)), "same_rep_frac": same_rep_frac, "time_gap_mean_same_rep": time_gap_mean, "near_time_frac_gap_le_5": near_5, "near_time_frac_gap_le_20": near_20, }) return pd.DataFrame(rows) def summarize_pass_rates(stats_df, summary_dir): entries = sorted(stats_df["entry"].unique()) rows = [] def get(entry, group, col): x = stats_df[(stats_df["entry"] == entry) & (stats_df["group"] == group)] if len(x) == 0: return np.nan return float(x.iloc[0][col]) for entry in entries: row = {"entry": entry} for mode in ["all", "cross", "same"]: h_r = get(entry, f"{mode}_high", "rmsd_A_mean") m_r = get(entry, f"{mode}_mid", "rmsd_A_mean") l_r = get(entry, f"{mode}_low", "rmsd_A_mean") h_c = get(entry, f"{mode}_high", "contact_diff_A_mean") m_c = get(entry, f"{mode}_mid", "contact_diff_A_mean") l_c = get(entry, f"{mode}_low", "contact_diff_A_mean") row[f"{mode}_rmsd_high"] = h_r row[f"{mode}_rmsd_mid"] = m_r row[f"{mode}_rmsd_low"] = l_r row[f"{mode}_contact_high"] = h_c row[f"{mode}_contact_mid"] = m_c row[f"{mode}_contact_low"] = l_c row[f"{mode}_delta_rmsd_low_high"] = l_r - h_r row[f"{mode}_delta_contact_low_high"] = l_c - h_c row[f"{mode}_rmsd_pass"] = int(h_r < l_r) row[f"{mode}_contact_pass"] = int(h_c < l_c) row[f"{mode}_strict_rmsd_pass"] = int(h_r < m_r < l_r) row[f"{mode}_strict_contact_pass"] = int(h_c < m_c < l_c) rows.append(row) pass_df = pd.DataFrame(rows) pass_path = summary_dir / "affinity_pass_summary.tsv" pass_df.to_csv(pass_path, sep="\t", index=False) report = {} print("\n=== Pass rate ===") for mode in ["all", "cross", "same"]: report[mode] = { "rmsd_pass": float(pass_df[f"{mode}_rmsd_pass"].mean()), "contact_pass": float(pass_df[f"{mode}_contact_pass"].mean()), "strict_rmsd_pass": float(pass_df[f"{mode}_strict_rmsd_pass"].mean()), "strict_contact_pass": float(pass_df[f"{mode}_strict_contact_pass"].mean()), "mean_delta_rmsd_low_high": float(pass_df[f"{mode}_delta_rmsd_low_high"].mean()), "mean_delta_contact_low_high": float(pass_df[f"{mode}_delta_contact_low_high"].mean()), } print(f"\n[{mode}]") for k, v in report[mode].items(): print(f"{k}: {v}") with open(summary_dir / "affinity_pass_report.json", "w") as f: json.dump(report, f, indent=2) return pass_df def save_minimal_cache(cache_dir, entry, q, top_idx, top_w, meta, compact=True): cache_dir.mkdir(parents=True, exist_ok=True) np.save(cache_dir / "q.npy", q.astype(np.float32)) if compact: n_frames = q.shape[0] if n_frames > 65535: raise RuntimeError( f"{entry}: n_frames={n_frames} > 65535, cannot save topk_neighbors as uint16." ) np.save(cache_dir / "topk_neighbors.npy", top_idx.astype(np.uint16)) np.save(cache_dir / "topk_weights.npy", top_w.astype(np.float16)) meta["dtype_q"] = "float32" meta["dtype_topk_neighbors"] = "uint16" meta["dtype_topk_weights"] = "float16" else: np.save(cache_dir / "topk_neighbors.npy", top_idx.astype(np.int32)) np.save(cache_dir / "topk_weights.npy", top_w.astype(np.float32)) meta["dtype_q"] = "float32" meta["dtype_topk_neighbors"] = "int32" meta["dtype_topk_weights"] = "float32" with open(cache_dir / "meta.json", "w") as f: json.dump(meta, f, indent=2) def process_one_entry(entry, args): atlas_root = Path(args.atlas_root) out_root = Path(args.out_root) entry_dir = atlas_root / entry cache_dir = out_root / entry q_file = cache_dir / "q.npy" topk_file = cache_dir / "topk_neighbors.npy" weight_file = cache_dir / "topk_weights.npy" meta_file = cache_dir / "meta.json" if ( q_file.exists() and topk_file.exists() and weight_file.exists() and meta_file.exists() and not args.overwrite ): if args.skip_existing_stats: return None coords_A, rep_ids, frame_ids, traj_lengths, rep_names, xtc_files = load_entry(entry_dir, entry) n_frames = coords_A.shape[0] n_ca = coords_A.shape[1] ca_pairs = select_ca_distance_pairs( coords_A[0], cutoff_A=args.contact_cutoff_A, min_seq_sep=args.min_seq_sep, max_pairs=args.max_pairs, ) X_dist = compute_distance_features( coords_A, ca_pairs, chunk_size=args.feature_chunk_size, ) X_mean = X_dist.mean(axis=0, keepdims=True) X_std = X_dist.std(axis=0, keepdims=True) + 1e-6 Xz = (X_dist - X_mean) / X_std pca_dim = min(args.pca_dim, Xz.shape[0] - 1, Xz.shape[1]) if pca_dim < 1: raise RuntimeError(f"{entry}: invalid PCA dim.") pca = PCA( n_components=pca_dim, svd_solver="randomized", random_state=args.seed, ) Y = pca.fit_transform(Xz).astype(np.float32) q, tica_evals = fit_tica( Y, traj_lengths=traj_lengths, lag=args.lag, tica_dim=args.tica_dim, ) A, top_idx, top_w = build_affinity_topk( q, sigma_k=args.sigma_k, top_k=args.top_k, ) meta = { "entry": entry, "n_frames": int(n_frames), "n_ca": int(n_ca), "n_replicates": int(len(traj_lengths)), "rep_names": rep_names, "traj_lengths": [int(x) for x in traj_lengths], "xtc_files": xtc_files, "pca_dim": int(pca_dim), "tica_dim": int(q.shape[1]), "tica_evals": [float(x) for x in tica_evals], "lag": int(args.lag), "sigma_k": int(args.sigma_k), "top_k": int(args.top_k), "contact_cutoff_A": float(args.contact_cutoff_A), "min_seq_sep": int(args.min_seq_sep), "max_pairs": int(args.max_pairs), "n_ca_pairs_used": int(len(ca_pairs)), "feature": "CA_pairwise_distances", "affinity": "exp(-||q_i-q_j||^2/(sigma_i*sigma_j))", "note": "Minimal training cache. Only q, top-k neighbors, top-k weights, and meta are saved.", } save_minimal_cache( cache_dir=cache_dir, entry=entry, q=q, top_idx=top_idx, top_w=top_w, meta=meta, compact=not args.no_compact, ) if args.no_stats: return None stats_df = evaluate_entry( entry=entry, A=A, coords_A=coords_A, X_dist=X_dist, rep_ids=rep_ids, frame_ids=frame_ids, n_sample=args.n_sample, ) return stats_df def main(): parser = argparse.ArgumentParser() parser.add_argument( "--atlas_root", default="/raid_zoe/home/lr/wangyi/p/atlas_1000_analysis", ) parser.add_argument( "--out_root", default="/raid_zoe/home/lr/wangyi/p/atlas_affinity_cache_min", ) parser.add_argument("--entry", default="all") parser.add_argument("--max_entries", type=int, default=None) parser.add_argument("--lag", type=int, default=10) parser.add_argument("--pca_dim", type=int, default=50) parser.add_argument("--tica_dim", type=int, default=3) parser.add_argument("--sigma_k", type=int, default=30) parser.add_argument("--top_k", type=int, default=64) parser.add_argument("--contact_cutoff_A", type=float, default=12.0) parser.add_argument("--min_seq_sep", type=int, default=3) parser.add_argument("--max_pairs", type=int, default=20000) parser.add_argument("--feature_chunk_size", type=int, default=256) parser.add_argument("--n_sample", type=int, default=3000) parser.add_argument("--seed", type=int, default=0) parser.add_argument("--overwrite", action="store_true") parser.add_argument("--no_compact", action="store_true") parser.add_argument("--no_stats", action="store_true") parser.add_argument("--skip_existing_stats", action="store_true") args = parser.parse_args() atlas_root = Path(args.atlas_root) out_root = Path(args.out_root) summary_dir = out_root / "_summary" log_dir = out_root / "_logs" out_root.mkdir(parents=True, exist_ok=True) summary_dir.mkdir(parents=True, exist_ok=True) log_dir.mkdir(parents=True, exist_ok=True) entries = find_entries( atlas_root, entry=args.entry, max_entries=args.max_entries, ) print(f"atlas_root: {atlas_root}") print(f"out_root: {out_root}") print(f"entries: {len(entries)}") print(f"minimal cache files per protein: q.npy, topk_neighbors.npy, topk_weights.npy, meta.json") print(f"compact mode: {not args.no_compact}") all_stats = [] success = [] failed = [] for entry in tqdm(entries, desc="proteins"): try: stats_df = process_one_entry(entry, args) success.append(entry) if stats_df is not None: all_stats.append(stats_df) except Exception as e: failed.append(entry) err_file = log_dir / f"{entry}.error.txt" with open(err_file, "w") as f: f.write(traceback.format_exc()) print(f"\n[FAILED] {entry}: {e}") with open(log_dir / "success.txt", "w") as f: f.write("\n".join(success) + "\n") with open(log_dir / "failed.txt", "w") as f: f.write("\n".join(failed) + "\n") if len(all_stats) > 0: all_stats_df = pd.concat(all_stats, axis=0, ignore_index=True) all_stats_path = summary_dir / "all_affinity_sanity_all_cross_same.tsv" all_stats_df.to_csv(all_stats_path, sep="\t", index=False) print(f"\nSaved sanity stats: {all_stats_path}") summarize_pass_rates(all_stats_df, summary_dir) print("\nDone.") print(f"Success: {len(success)}") print(f"Failed: {len(failed)}") print(f"Logs: {log_dir}") print(f"Summary: {summary_dir}") if __name__ == "__main__": main()