extraction.py

#!/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()