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